{
  "cells": [
    {
      "cell_type": "markdown",
      "metadata": {},
      "source": [
        "# Code Interpreting with OpenAI's o1 model\n",
        "This example uses the E2B's [Code Interpreter](https://github.com/e2b-dev/code-interpreter) as a tool for OpenAI's o1 model. We ask o1 to generate Python code to train a machine learning model based on Kaggle's [Machine Learning from Disaster](https://www.kaggle.com/competitions/titanic) challenge and display the results in a graph.\n",
        "\n",
        "We use two LLMs:\n",
        "1. o1-mini to generate a thorough plan for the task with many code blocks\n",
        "2. gpt-4o-mini to extract the final code from the plan generated by o1-mini"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 1,
      "metadata": {
        "id": "Z7uxglM8rkss"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "Requirement already satisfied: openai in /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages (1.45.0)\n",
            "Requirement already satisfied: e2b_code_interpreter in /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages (0.0.10)\n",
            "Requirement already satisfied: python-dotenv in /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages (1.0.1)\n",
            "Requirement already satisfied: anyio<5,>=3.5.0 in /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages (from openai) (3.7.1)\n",
            "Requirement already satisfied: distro<2,>=1.7.0 in /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages (from openai) (1.8.0)\n",
            "Requirement already satisfied: httpx<1,>=0.23.0 in /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages (from openai) (0.27.0)\n",
            "Requirement already satisfied: jiter<1,>=0.4.0 in /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages (from openai) (0.4.1)\n",
            "Requirement already satisfied: pydantic<3,>=1.9.0 in /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages (from openai) (2.9.1)\n",
            "Requirement already satisfied: sniffio in /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages (from openai) (1.3.0)\n",
            "Requirement already satisfied: tqdm>4 in /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages (from openai) (4.66.2)\n",
            "Requirement already satisfied: typing-extensions<5,>=4.11 in /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages (from openai) (4.12.2)\n",
            "Requirement already satisfied: e2b>=0.17.1 in /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages (from e2b_code_interpreter) (0.17.1)\n",
            "Requirement already satisfied: websocket-client<2.0.0,>=1.7.0 in /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages (from e2b_code_interpreter) (1.7.0)\n",
            "Requirement already satisfied: idna>=2.8 in /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages (from anyio<5,>=3.5.0->openai) (3.6)\n",
            "Requirement already satisfied: aenum>=3.1.11 in /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages (from e2b>=0.17.1->e2b_code_interpreter) (3.1.15)\n",
            "Requirement already satisfied: aiohttp>=3.8.4 in /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages (from e2b>=0.17.1->e2b_code_interpreter) (3.9.5)\n",
            "Requirement already satisfied: jsonrpcclient>=4.0.3 in /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages (from e2b>=0.17.1->e2b_code_interpreter) (4.0.3)\n",
            "Requirement already satisfied: python-dateutil>=2.8.2 in /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages (from e2b>=0.17.1->e2b_code_interpreter) (2.8.2)\n",
            "Requirement already satisfied: requests>=2.31.0 in /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages (from e2b>=0.17.1->e2b_code_interpreter) (2.31.0)\n",
            "Requirement already satisfied: urllib3>=1.25.3 in /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages (from e2b>=0.17.1->e2b_code_interpreter) (2.2.1)\n",
            "Requirement already satisfied: websockets>=11.0.3 in /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages (from e2b>=0.17.1->e2b_code_interpreter) (11.0.3)\n",
            "Requirement already satisfied: certifi in /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages (from httpx<1,>=0.23.0->openai) (2024.2.2)\n",
            "Requirement already satisfied: httpcore==1.* in /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages (from httpx<1,>=0.23.0->openai) (1.0.2)\n",
            "Requirement already satisfied: h11<0.15,>=0.13 in /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages (from httpcore==1.*->httpx<1,>=0.23.0->openai) (0.14.0)\n",
            "Requirement already satisfied: annotated-types>=0.6.0 in /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages (from pydantic<3,>=1.9.0->openai) (0.7.0)\n",
            "Requirement already satisfied: pydantic-core==2.23.3 in /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages (from pydantic<3,>=1.9.0->openai) (2.23.3)\n",
            "Requirement already satisfied: aiosignal>=1.1.2 in /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages (from aiohttp>=3.8.4->e2b>=0.17.1->e2b_code_interpreter) (1.3.1)\n",
            "Requirement already satisfied: attrs>=17.3.0 in /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages (from aiohttp>=3.8.4->e2b>=0.17.1->e2b_code_interpreter) (23.1.0)\n",
            "Requirement already satisfied: frozenlist>=1.1.1 in /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages (from aiohttp>=3.8.4->e2b>=0.17.1->e2b_code_interpreter) (1.4.0)\n",
            "Requirement already satisfied: multidict<7.0,>=4.5 in /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages (from aiohttp>=3.8.4->e2b>=0.17.1->e2b_code_interpreter) (6.0.4)\n",
            "Requirement already satisfied: yarl<2.0,>=1.0 in /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages (from aiohttp>=3.8.4->e2b>=0.17.1->e2b_code_interpreter) (1.9.2)\n",
            "Requirement already satisfied: six>=1.5 in /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages (from python-dateutil>=2.8.2->e2b>=0.17.1->e2b_code_interpreter) (1.16.0)\n",
            "Requirement already satisfied: charset-normalizer<4,>=2 in /Library/Frameworks/Python.framework/Versions/3.11/lib/python3.11/site-packages (from requests>=2.31.0->e2b>=0.17.1->e2b_code_interpreter) (3.3.2)\n",
            "Note: you may need to restart the kernel to use updated packages.\n"
          ]
        }
      ],
      "source": [
        "%pip install openai e2b_code_interpreter==1.0.0 python-dotenv"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 2,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "Fw165_Rl7go4",
        "outputId": "ee53a14c-752c-413b-c2b0-4c1e3a33de59"
      },
      "outputs": [],
      "source": [
        "# Get your API keys or save them to .env file.\n",
        "import os\n",
        "from dotenv import load_dotenv\n",
        "load_dotenv()\n",
        "\n",
        "# TODO: Get your OpenAI API key from https://platform.openai.com/api-keys\n",
        "OPENAI_API_KEY = os.getenv(\"OPENAI_API_KEY\")\n",
        "\n",
        "# TODO: Get your E2B API key from https://e2b.dev/docs\n",
        "E2B_API_KEY = os.getenv(\"E2B_API_KEY\")\n",
        "\n",
        "O1_PROMPT = \"\"\"You're a data scientist analyzing survival data from the Titanic Disaster. You are given tasks to complete and you run Python code to solve them.\n",
        "\n",
        "Information about the Titanic dataset:\n",
        "- It's in the `/home/user/train.csv` and `/home/user/test.csv` files\n",
        "- The CSV files are using `,` as the delimiter\n",
        "- They have following columns:\n",
        "  - PassengerId: Unique passenger ID\n",
        "  - Pclass: 1st, 2nd, 3rd (Ticket class)\n",
        "  - Name: Passenger name\n",
        "  - Sex: Gender\n",
        "  - Age: Age in years\n",
        "  - SibSp: Number of siblings/spouses aboard\n",
        "  - Parch: Number of parents/children aboard\n",
        "  - Ticket: Ticket number\n",
        "  - Fare: Passenger fare\n",
        "  - Cabin: Cabin number\n",
        "  - Embarked: Port of Embarkation (C = Cherbourg, Q = Queenstown, S = Southampton)\n",
        "\n",
        "Generally, you follow these rules:\n",
        "- ALWAYS FORMAT YOUR RESPONSE IN MARKDOWN\n",
        "- ALWAYS RESPOND ONLY WITH CODE IN CODE BLOCK LIKE THIS:\n",
        "```python\n",
        "{code}\n",
        "```\n",
        "- the python code runs in jupyter notebook.\n",
        "- every time you generate python, the code is executed in a separate cell. it's okay to multiple calls to `execute_python`.\n",
        "- display visualizations using matplotlib or any other visualization library directly in the notebook. don't worry about saving the visualizations to a file.\n",
        "- you have access to the internet and can make api requests.\n",
        "- you also have access to the filesystem and can read/write files.\n",
        "- install all packages before using by running `!pip install {package}`.\n",
        "- you can run any python code you want, everything is running in a secure sandbox environment\n",
        "\"\"\"\n",
        "\n",
        "GPT_4O_PROMPT = \"You are an expert software engineer that receives an execution plan, and then creates a single Python script that does everything in the plan. It will be executed in a single Python notebook cell.\""
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 3,
      "metadata": {
        "id": "UT578ezzr4RN"
      },
      "outputs": [],
      "source": [
        "import re\n",
        "pattern = re.compile(r'```python\\n(.*?)\\n```', re.DOTALL)  # Match everything in between ```python and ```\n",
        "\n",
        "def match_code_blocks(llm_response):\n",
        "    matches = pattern.findall(llm_response)  # Find all matches\n",
        "    if matches:\n",
        "        code = \"\\n\".join(matches)  # Concatenate all code blocks with newlines\n",
        "        print(\"> LLM-generated code:\")\n",
        "        print(code)\n",
        "        return code\n",
        "    return \"\""
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 4,
      "metadata": {
        "id": "wzoaB4yYskGO"
      },
      "outputs": [],
      "source": [
        "from openai import OpenAI\n",
        "\n",
        "def chat(e2b_code_interpreter, user_message):\n",
        "  print(f\"\\n{'='*50}\\nUser message: {user_message}\\n{'='*50}\")\n",
        "\n",
        "  client = OpenAI(api_key=OPENAI_API_KEY)\n",
        "\n",
        "  # First we get the plan from o1\n",
        "  response_o1 = client.chat.completions.create(\n",
        "    model=\"o1-mini\",\n",
        "    messages=[\n",
        "      {\"role\": \"user\", \"content\": O1_PROMPT},\n",
        "      {\"role\": \"user\", \"content\": user_message}\n",
        "  ])\n",
        "  content_o1 = response_o1.choices[0].message.content\n",
        "\n",
        "  # Then we use gpt-4o-mini to extract the code from the plan we got from o1\n",
        "  response_4o = client.chat.completions.create(\n",
        "    model=\"gpt-4o-mini\",\n",
        "    messages=[\n",
        "        {\"role\": \"system\", \"content\": GPT_4O_PROMPT},\n",
        "        {\"role\": \"user\", \"content\": f\"This is the plan I received, please write fully functional code that I can run in one notebook cell, and list all its dependencies: {content_o1}\"},\n",
        "  ])\n",
        "  content_4o = response_4o.choices[0].message.content\n",
        "  python_code = match_code_blocks(content_4o)\n",
        "\n",
        "  if python_code != \"\":\n",
        "    code_interpreter_results = code_interpret(e2b_code_interpreter, python_code)\n",
        "    return code_interpreter_results\n",
        "  else:\n",
        "    print(f\"Failed to match any Python code in model's response {content_4o}\")\n",
        "    return[]"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 5,
      "metadata": {
        "id": "wSBB7e1Tsnav"
      },
      "outputs": [],
      "source": [
        "def upload_dataset(code_interpreter):\n",
        "  print(\"Uploading testing and training datasets to Code Interpreter sandbox...\")\n",
        "  file_path = \"./test.csv\"\n",
        "  with open(file_path, \"rb\") as f:\n",
        "    code_interpreter.files.write(file_path, f)\n",
        "    print(\"Uploaded test.csv at\", file_path)\n",
        "  file_path = \"./train.csv\"\n",
        "  with open(file_path, \"rb\") as f:\n",
        "    code_interpreter.files.write(file_path, f)\n",
        "    print(\"Uploaded train.csv at\", file_path)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 6,
      "metadata": {
        "id": "Hibi4_ZluIRb"
      },
      "outputs": [],
      "source": [
        "def code_interpret(e2b_code_interpreter, code):\n",
        "  print(\"Running code interpreter...\")\n",
        "  exec = e2b_code_interpreter.run_code(code,\n",
        "  on_stderr=lambda stderr: print(\"[Code Interpreter]\", stderr),\n",
        "  on_stdout=lambda stdout: print(\"[Code Interpreter]\", stdout))\n",
        "\n",
        "  if exec.error:\n",
        "    print(\"[Code Interpreter ERROR]\", exec.error)\n",
        "  else:\n",
        "    return exec.results"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 7,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 1000
        },
        "id": "b4VsGbZyspXb",
        "outputId": "cf82fa50-355f-438d-e2c5-6adef7e28abf"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "Uploading testing and training datasets to Code Interpreter sandbox...\n",
            "Uploaded test.csv at /home/user/test.csv\n",
            "Uploaded train.csv at /home/user/train.csv\n",
            "\n",
            "==================================================\n",
            "User message: Clean the data, train a decision tree to predict the survival of passengers, and visualize the learning curve. Then run the model the test dataset and print the results.\n",
            "==================================================\n",
            "> LLM-generated code:\n",
            "# Install dependencies\n",
            "!pip install pandas numpy scikit-learn matplotlib\n",
            "\n",
            "# Import necessary libraries\n",
            "import pandas as pd\n",
            "import numpy as np\n",
            "from sklearn.model_selection import train_test_split, learning_curve\n",
            "from sklearn.tree import DecisionTreeClassifier\n",
            "from sklearn.preprocessing import LabelEncoder\n",
            "import matplotlib.pyplot as plt\n",
            "\n",
            "# Load the data\n",
            "train_data = pd.read_csv('/home/user/train.csv')\n",
            "test_data = pd.read_csv('/home/user/test.csv')\n",
            "\n",
            "# Combine train and test data for consistent preprocessing\n",
            "train_data['TrainSplit'] = 'train'\n",
            "test_data['Survived'] = np.nan  # Add Survived column to test data\n",
            "test_data['TrainSplit'] = 'test'\n",
            "combined = pd.concat([train_data, test_data], sort=False)\n",
            "\n",
            "# Handle missing values\n",
            "# Fill Age with median\n",
            "combined['Age'].fillna(combined['Age'].median(), inplace=True)\n",
            "\n",
            "# Fill Embarked with mode\n",
            "combined['Embarked'].fillna(combined['Embarked'].mode()[0], inplace=True)\n",
            "\n",
            "# Fill Fare with median\n",
            "combined['Fare'].fillna(combined['Fare'].median(), inplace=True)\n",
            "\n",
            "# Drop Cabin as it has many missing values\n",
            "combined.drop('Cabin', axis=1, inplace=True)\n",
            "\n",
            "# Encode categorical variables\n",
            "label_encoders = {}\n",
            "categorical_features = ['Sex', 'Embarked']\n",
            "\n",
            "for feature in categorical_features:\n",
            "    le = LabelEncoder()\n",
            "    combined[feature] = le.fit_transform(combined[feature])\n",
            "    label_encoders[feature] = le\n",
            "\n",
            "# Split the data back into train and test\n",
            "train_clean = combined[combined['TrainSplit'] == 'train'].drop(['TrainSplit'], axis=1)\n",
            "test_clean = combined[combined['TrainSplit'] == 'test'].drop(['TrainSplit', 'Survived'], axis=1)\n",
            "\n",
            "# Define features and target\n",
            "features = ['Pclass', 'Sex', 'Age', 'SibSp', 'Parch', 'Fare', 'Embarked']\n",
            "X = train_clean[features]\n",
            "y = train_clean['Survived']\n",
            "\n",
            "# Split into training and validation sets\n",
            "X_train, X_val, y_train, y_val = train_test_split(X, y, test_size=0.2, random_state=42)\n",
            "\n",
            "# Initialize the Decision Tree Classifier\n",
            "clf = DecisionTreeClassifier(random_state=42)\n",
            "\n",
            "# Plot learning curve\n",
            "train_sizes, train_scores, test_scores = learning_curve(clf, X_train, y_train, cv=5, \n",
            "                                                        train_sizes=np.linspace(0.1, 1.0, 10), \n",
            "                                                        scoring='accuracy')\n",
            "\n",
            "train_scores_mean = train_scores.mean(axis=1)\n",
            "test_scores_mean = test_scores.mean(axis=1)\n",
            "\n",
            "plt.figure(figsize=(10,6))\n",
            "plt.plot(train_sizes, train_scores_mean, 'o-', color=\"r\", label=\"Training score\")\n",
            "plt.plot(train_sizes, test_scores_mean, 'o-', color=\"g\", label=\"Cross-validation score\")\n",
            "plt.title(\"Learning Curve for Decision Tree Classifier\")\n",
            "plt.xlabel(\"Training Examples\")\n",
            "plt.ylabel(\"Score\")\n",
            "plt.legend(loc=\"best\")\n",
            "plt.grid()\n",
            "plt.show()\n",
            "\n",
            "# Train the model on the entire training set\n",
            "clf.fit(X_train, y_train)\n",
            "\n",
            "# Prepare test data\n",
            "X_test = test_clean[features]\n",
            "\n",
            "# Make predictions\n",
            "test_predictions = clf.predict(X_test)\n",
            "\n",
            "# Prepare the results DataFrame\n",
            "results = pd.DataFrame({\n",
            "    'PassengerId': test_data['PassengerId'],\n",
            "    'Survived': test_predictions\n",
            "})\n",
            "\n",
            "print(results)\n",
            "Running code interpreter...\n",
            "[Code Interpreter] Requirement already satisfied: pandas in /usr/local/lib/python3.10/site-packages (1.5.3)\n",
            "Requirement already satisfied: numpy in /usr/local/lib/python3.10/site-packages (1.26.4)\n",
            "Requirement already satisfied: scikit-learn in /usr/local/lib/python3.10/site-packages (1.4.1.post1)\n",
            "Requirement already satisfied: matplotlib in /usr/local/lib/python3.10/site-packages (3.8.3)\n",
            "Requirement already satisfied: python-dateutil>=2.8.1 in /usr/local/lib/python3.10/site-packages (from pandas) (2.9.0.post0)\n",
            "Requirement already satisfied: pytz>=2020.1 in /usr/local/lib/python3.10/site-packages (from pandas) (2024.1)\n",
            "\n",
            "[Code Interpreter] Requirement already satisfied: scipy>=1.6.0 in /usr/local/lib/python3.10/site-packages (from scikit-learn) (1.12.0)\n",
            "Requirement already satisfied: threadpoolctl>=2.0.0 in /usr/local/lib/python3.10/site-packages (from scikit-learn) (3.5.0)\n",
            "\n",
            "[Code Interpreter] Requirement already satisfied: joblib>=1.2.0 in /usr/local/lib/python3.10/site-packages (from scikit-learn) (1.3.2)\n",
            "Requirement already satisfied: contourpy>=1.0.1 in /usr/local/lib/python3.10/site-packages (from matplotlib) (1.2.1)\n",
            "Requirement already satisfied: fonttools>=4.22.0 in /usr/local/lib/python3.10/site-packages (from matplotlib) (4.53.1)\n",
            "Requirement already satisfied: packaging>=20.0 in /usr/local/lib/python3.10/site-packages (from matplotlib) (24.1)\n",
            "Requirement already satisfied: cycler>=0.10 in /usr/local/lib/python3.10/site-packages (from matplotlib) (0.12.1)\n",
            "Requirement already satisfied: kiwisolver>=1.3.1 in /usr/local/lib/python3.10/site-packages (from matplotlib) (1.4.5)\n",
            "Requirement already satisfied: pillow>=8 in /usr/local/lib/python3.10/site-packages (from matplotlib) (10.4.0)\n",
            "Requirement already satisfied: pyparsing>=2.3.1 in /usr/local/lib/python3.10/site-packages (from matplotlib) (3.1.2)\n",
            "\n",
            "[Code Interpreter] Requirement already satisfied: six>=1.5 in /usr/local/lib/python3.10/site-packages (from python-dateutil>=2.8.1->pandas) (1.16.0)\n",
            "\n",
            "[Code Interpreter] \u001b[33mWARNING: Running pip as the 'root' user can result in broken permissions and conflicting behaviour with the system package manager. It is recommended to use a virtual environment instead: https://pip.pypa.io/warnings/venv\u001b[0m\u001b[33m\n",
            "\u001b[0m\n",
            "[Code Interpreter] \n",
            "\u001b[1m[\u001b[0m\u001b[34;49mnotice\u001b[0m\u001b[1;39;49m]\u001b[0m\u001b[39;49m A new release of pip is available: \u001b[0m\u001b[31;49m23.0.1\u001b[0m\u001b[39;49m -> \u001b[0m\u001b[32;49m24.2\u001b[0m\n",
            "\u001b[1m[\u001b[0m\u001b[34;49mnotice\u001b[0m\u001b[1;39;49m]\u001b[0m\u001b[39;49m To update, run: \u001b[0m\u001b[32;49mpip install --upgrade pip\u001b[0m\n",
            "\n",
            "[Code Interpreter]      PassengerId  Survived\n",
            "0            892       0.0\n",
            "1            893       1.0\n",
            "2            894       1.0\n",
            "3            895       1.0\n",
            "4            896       1.0\n",
            "..           ...       ...\n",
            "413         1305       0.0\n",
            "414         1306       1.0\n",
            "415         1307       0.0\n",
            "416         1308       0.0\n",
            "417         1309       0.0\n",
            "\n",
            "[418 rows x 2 columns]\n",
            "\n"
          ]
        },
        {
          "data": {
            "image/png": "iVBORw0KGgoAAAANSUhEUgAAA1cAAAIjCAYAAADvBuGTAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjguMywgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/H5lhTAAAACXBIWXMAAA9hAAAPYQGoP6dpAACPwUlEQVR4nOzdd3gUVcPG4Wez6QlJqEmogdCRojSRqpQgilRpFkDFioJYXvCVZosNBBu8FgQrIM0CAhEBAZFeVIp0kBJqSEhIssnO90e+rCzZ9E025Xdf11xkz56ZPTN7NuyTM3PGZBiGIQAAAABAvri5ugEAAAAAUBIQrgAAAADACQhXAAAAAOAEhCsAAAAAcALCFQAAAAA4AeEKAAAAAJyAcAUAAAAATkC4AgAAAAAnIFwBAAAAgBMQrgAgG2FhYRo2bJirm1HivPXWW6pVq5bMZrOaNWvm6uYUqNmzZ8tkMuno0aO5Ws9kMmnSpEkF0qbSxNXHsVOnTurUqZNdWXR0tPr376/y5cvLZDJp2rRpWrNmjUwmk9asWeOSdgLIP8IVgEKR/uVy69atrm5KsZOYmKh33nlHrVu3VmBgoLy9vVW3bl2NHDlSf//9t6ublycrV67U888/r7Zt2+qzzz7Ta6+9VqCvN2zYMJlMJtvi7++vWrVqqX///lq4cKGsVmuBvn5xcfToUbvjlNWS26BYEHbu3Kl7771X1apVk5eXl8qVK6cuXbros88+U2pqqqubl6Wnn35aK1as0Lhx4/TFF1+oe/furm4SACdwd3UDAKCo279/v9zcXPO3qPPnz6t79+7atm2b7rzzTg0ZMkT+/v7av3+/5s6dq48++kjJyckuaVt+/PLLL3Jzc9Onn34qT0/PQnlNLy8vffLJJ5Kkq1ev6tixY/rhhx/Uv39/derUSd99950CAgIK5LXvu+8+DRo0SF5eXrla7+rVq3J3L7z/qitWrKgvvvjCrmzKlCn6559/9M4772So60qffPKJHn30UQUHB+u+++5TnTp1FBcXp1WrVunBBx/U6dOn9cILL7i0jelWrlyZoeyXX35Rr1699Oyzz9rK6tatq6tXrxbaZwKA8xGuAJQqKSkpslqtufryktsvxM40bNgw7dixQwsWLFC/fv3snnv55Zf13//+1ymvk5fjkh9nz56Vj4+P017PMAwlJibKx8cn0zru7u6699577cpeeeUVvf766xo3bpxGjBihefPmOaU91zObzTKbzblez9vbuwBakzk/P78Mx2ju3Lm6dOlShvJr5eT4O9Pvv/+uRx99VG3atNGyZctUpkwZ23OjR4/W1q1b9eeffxZKW3LCUT8/e/asgoKC7Mrc3Nyc+p7Hx8fLz8/PadsDkD1OCwRQpJw8eVIPPPCAgoOD5eXlpUaNGmnWrFl2dZKTkzVhwgQ1b95cgYGB8vPzU/v27bV69Wq7eumnOL399tuaNm2awsPD5eXlpT179mjSpEkymUw6ePCghg0bpqCgIAUGBmr48OFKSEiw287111yln+K4YcMGjRkzRhUrVpSfn5/69Omjc+fO2a1rtVo1adIkVa5cWb6+vrr11lu1Z8+eHF3HtWnTJi1dulQPPvhghmAlpYW+t99+2/bY0XUdUlpACwsLy/a47NixQ+7u7po8eXKGbezfv18mk0nvv/++rSwmJkajR4+2nZJVu3ZtvfHGG9meYmcymfTZZ58pPj7edorZ7NmzJaWFvJdfftnWprCwML3wwgtKSkqy20ZYWJjuvPNOrVixQi1atJCPj4/+97//Zfm6mRk7dqy6deumb7/9NsNplj/99JPat28vPz8/lSlTRnfccYf++uuvDNvYt2+fBgwYoIoVK8rHx0f16tWzC76OrrnaunWrIiIiVKFCBfn4+KhmzZp64IEHMhyr668V2rFjh26//XYFBATI399fnTt31u+//25XJzd9NC+yOv457RdWq1XTpk1To0aN5O3treDgYD3yyCO6dOlStq8/efJkmUwmffXVV3bBKl2LFi2y/HwdO3ZMjz/+uOrVqycfHx+VL19ed999d4ZTHS0WiyZPnqw6derI29tb5cuXV7t27RQVFWWrc+bMGQ0fPlxVq1aVl5eXQkND1atXL7ttXfvZTH9vDMPQBx98YPsMSMr0mqtNmzape/fuCgwMlK+vrzp27KgNGzbY1Un/nbZnzx4NGTJEZcuWVbt27bI9lgCci5ErAEVGdHS0br75ZplMJo0cOVIVK1bUTz/9pAcffFCxsbEaPXq0JCk2NlaffPKJBg8erBEjRiguLk6ffvqpIiIitHnz5gyTI3z22WdKTEzUww8/bLsuI92AAQNUs2ZNRUZGavv27frkk09UqVIlvfHGG9m298knn1TZsmU1ceJEHT16VNOmTdPIkSPtRj/GjRunN998Uz179lRERIR27dqliIgIJSYmZrv977//XlLaKWUF4frjEhoaqo4dO2r+/PmaOHGiXd158+bJbDbr7rvvliQlJCSoY8eOOnnypB555BFVr15dv/32m8aNG6fTp09r2rRpmb7uF198oY8++kibN2+2naZ3yy23SJIeeughzZkzR/3799czzzyjTZs2KTIyUnv37tXixYvttrN//34NHjxYjzzyiEaMGKF69erl+Vjcd999WrlypaKiolS3bl1bO4cOHaqIiAi98cYbSkhI0IwZM9SuXTvt2LHDFlh3796t9u3by8PDQw8//LDCwsJ06NAh/fDDD3r11Vcdvt7Zs2fVrVs3VaxYUWPHjlVQUJCOHj2qRYsWZdnOv/76S+3bt1dAQICef/55eXh46H//+586deqktWvXqnXr1nb1c9JH88rR8c9Nv3jkkUc0e/ZsDR8+XE899ZSOHDmi999/Xzt27NCGDRvk4eHh8HUTEhK0atUqdejQQdWrV89T27ds2aLffvtNgwYNUtWqVXX06FHNmDFDnTp10p49e+Tr6yspLbBERkbqoYceUqtWrRQbG6utW7dq+/bt6tq1qySpX79++uuvv/Tkk08qLCxMZ8+eVVRUlI4fP273R410HTp00BdffKH77rtPXbt21f33359lW3/55Rfdfvvtat68uSZOnCg3Nzd99tlnuu2227Ru3Tq1atXKrv7dd9+tOnXq6LXXXpNhGHk6PgDywQCAQvDZZ58ZkowtW7ZkWufBBx80QkNDjfPnz9uVDxo0yAgMDDQSEhIMwzCMlJQUIykpya7OpUuXjODgYOOBBx6wlR05csSQZAQEBBhnz561qz9x4kRDkl19wzCMPn36GOXLl7crq1GjhjF06NAM+9KlSxfDarXayp9++mnDbDYbMTExhmEYxpkzZwx3d3ejd+/edtubNGmSIclum4706dPHkGRcunQpy3rpOnbsaHTs2DFD+dChQ40aNWrYHmd1XP73v/8Zkow//vjDrrxhw4bGbbfdZnv88ssvG35+fsbff/9tV2/s2LGG2Ww2jh8/nmVbhw4davj5+dmV7dy505BkPPTQQ3blzz77rCHJ+OWXX2xlNWrUMCQZy5cvz/J1snq9a+3YscOQZDz99NOGYRhGXFycERQUZIwYMcKu3pkzZ4zAwEC78g4dOhhlypQxjh07Zlf32r6R3meOHDliGIZhLF68ONvPg2EYhiRj4sSJtse9e/c2PD09jUOHDtnKTp06ZZQpU8bo0KFDhtfLro/mxB133GHXfwwj8+Of036xbt06Q5Lx1Vdf2dVbvny5w/Jr7dq1y5BkjBo1Ksf7cP1xTP9dcq2NGzcakozPP//cVta0aVPjjjvuyHS7ly5dMiQZb731Vpav7+izKcl44okn7MpWr15tSDJWr15tGEZaH6pTp44RERFh9z4mJCQYNWvWNLp27WorS/+dNnjw4CzbAqBgcVoggCLBMAwtXLhQPXv2lGEYOn/+vG2JiIjQ5cuXtX37dklp16+kX8NgtVp18eJFpaSkqEWLFrY61+rXr1+mF98/+uijdo/bt2+vCxcuKDY2Nts2P/zww7bTedLXTU1N1bFjxyRJq1atUkpKih5//HG79Z588slsty3J1gZHpz05g6Pj0rdvX7m7u9uNbPz555/as2ePBg4caCv79ttv1b59e5UtW9buverSpYtSU1P166+/5ro9y5YtkySNGTPGrvyZZ56RJC1dutSuvGbNmoqIiMj16zji7+8vSYqLi5MkRUVFKSYmRoMHD7bbP7PZrNatW9tOQT137px+/fVXPfDAAxlGUa7tG9dLv9bmxx9/lMViyVEbU1NTtXLlSvXu3Vu1atWylYeGhmrIkCFav359hn6bXR/ND0fHP6f94ttvv1VgYKC6du1qV6958+by9/fPcIrvtZzxubj22jCLxaILFy6odu3aCgoKsvsdEhQUpL/++ksHDhzIdDuenp5as2ZNjk5nzK2dO3fqwIEDGjJkiC5cuGA7TvHx8ercubN+/fXXDKdbXv87DUDh4rRAAEXCuXPnFBMTo48++kgfffSRwzpnz561/TxnzhxNmTJF+/bts/tyWrNmzQzrOSpLd/0X4rJly0qSLl26lO3McVmtK8n2BbZ27dp29cqVK2erm5X014+Li8tw4bszODouFSpUUOfOnTV//ny9/PLLktJOCXR3d1ffvn1t9Q4cOKDdu3dnGlqvfa9y6tixY3Jzc8twvEJCQhQUFJQhEGT1vubWlStXJP37hT39y/Rtt93msH76e3P48GFJ0g033JCr1+vYsaP69eunyZMn65133lGnTp3Uu3dvDRkyJNMJVM6dO6eEhASHpz82aNBAVqtVJ06cUKNGjWzl2fXR/HB0/HPaLw4cOKDLly+rUqVKWdZz5NrPRV5dvXpVkZGR+uyzz3Ty5Em70+cuX75s+/mll15Sr169VLduXd1www3q3r277rvvPjVp0kRS2nWPb7zxhp555hkFBwfr5ptv1p133qn7779fISEheW5fuvR+OHTo0EzrXL582e73iTM/FwByj3AFoEhI/+vrvffem+kXifQvNF9++aWGDRum3r1767nnnlOlSpVkNpsVGRmpQ4cOZVgvqxnMMpvBzcjBtQr5WTcn6tevL0n6448/1L59+2zrp18kf73M7veT2XEZNGiQhg8frp07d6pZs2aaP3++OnfurAoVKtjqWK1Wde3aVc8//7zDbaRft5QXWY34XMuZM9OlzyyXHuzS++MXX3zh8EtyfqdHN5lMWrBggX7//Xf98MMPWrFihR544AFNmTJFv//+u20kLb8Kso86Ov457RdWq1WVKlXSV1995bBeVtO8165dW+7u7vrjjz/y0Oo0Tz75pD777DONHj1abdq0UWBgoEwmkwYNGmQ3EtShQwcdOnRI3333nVauXKlPPvlE77zzjmbOnKmHHnpIUtrshD179tSSJUu0YsUKjR8/XpGRkfrll19044035rmN0r/98K233sr0RtvX95XCmrERgGOEKwBFQsWKFVWmTBmlpqaqS5cuWdZdsGCBatWqpUWLFtl9Eb9+EgZXq1GjhiTp4MGDdn9NvnDhQo5GDnr27KnIyEh9+eWXOQpXZcuWtY2kXCu3p4D17t1bjzzyiO3UwL///lvjxo2zqxMeHq4rV65k+17lRo0aNWS1WnXgwAE1aNDAVh4dHa2YmBjb8SwIX3zxhUwmk22SgvDwcElSpUqVstzH9NPz8jrt980336ybb75Zr776qr7++mvdc889mjt3ru2L+7UqVqwoX19f7d+/P8Nz+/btk5ubm6pVq5andjhLTvtFeHi4fv75Z7Vt2zbXYcDX11e33XabfvnlF504cSJP+7xgwQINHTpUU6ZMsZUlJiYqJiYmQ91y5cpp+PDhGj58uK5cuaIOHTpo0qRJdu9ReHi4nnnmGT3zzDM6cOCAmjVrpilTpujLL7/Mdduuld4PAwICnPpZA1BwuOYKQJFgNpvVr18/LVy40OEX1Wunj07/a/y1f33ftGmTNm7cWPANzYXOnTvL3d1dM2bMsCu/djrzrLRp00bdu3fXJ598oiVLlmR4Pjk52e4GpOHh4dq3b5/dsdq1a1eGKZuzExQUpIiICM2fP19z586Vp6enevfubVdnwIAB2rhxo1asWJFh/ZiYGKWkpOTqNSWpR48ekpRhpsGpU6dKku64445cbzMnXn/9da1cuVIDBw5UnTp1JEkREREKCAjQa6+95vCaqPRjXLFiRXXo0EGzZs3S8ePH7epkNTp06dKlDM+nj0xcP+18OrPZrG7duum7776zm+Y7OjpaX3/9tdq1a1dgN0HOqZz2iwEDBig1NdV26um1UlJSHIaca02cOFGGYei+++6zndJ5rW3btmnOnDmZrm82mzMc//feey/DKO+FCxfsHvv7+6t27dq29yghISHDzJ/h4eEqU6ZMpu9jbjRv3lzh4eF6++23He6nM6bVB+BcjFwBKFSzZs3S8uXLM5SPGjVKr7/+ulavXq3WrVtrxIgRatiwoS5evKjt27fr559/1sWLFyVJd955pxYtWqQ+ffrojjvu0JEjRzRz5kw1bNjQ4RcQVwkODtaoUaM0ZcoU3XXXXerevbt27dqln376SRUqVMjR6W+ff/65unXrpr59+6pnz57q3Lmz/Pz8dODAAc2dO1enT5+23evqgQce0NSpUxUREaEHH3xQZ8+e1cyZM9WoUaMcTdBxrYEDB+ree+/Vhx9+qIiIiAzXfD333HP6/vvvdeedd2rYsGFq3ry54uPj9ccff2jBggU6evSo3WmEOdG0aVMNHTpUH330kWJiYtSxY0dt3rxZc+bMUe/evXXrrbfmanvXS0lJsY0kJCYm6tixY/r++++1e/du3XrrrXbX+gUEBGjGjBm67777dNNNN2nQoEGqWLGijh8/rqVLl6pt27a2kPzuu++qXbt2uummm/Twww+rZs2aOnr0qJYuXaqdO3c6bMucOXP04Ycfqk+fPgoPD1dcXJw+/vhjBQQE2EKmI6+88oqioqLUrl07Pf7443J3d9f//vc/JSUl6c0338zX8XGGnPaLjh076pFHHlFkZKR27typbt26ycPDQwcOHNC3336r6dOnq3///pm+zi233KIPPvhAjz/+uOrXr6/77rtPderUUVxcnNasWaPvv/9er7zySqbr33nnnfriiy8UGBiohg0bauPGjfr5559Vvnx5u3oNGzZUp06d1Lx5c5UrV05bt27VggULNHLkSElpo7qdO3fWgAED1LBhQ7m7u2vx4sWKjo7WoEGD8n083dzc9Mknn+j2229Xo0aNNHz4cFWpUkUnT57U6tWrFRAQoB9++CHfrwPAiVwzSSGA0iZ9aujMlhMnThiGYRjR0dHGE088YVSrVs3w8PAwQkJCjM6dOxsfffSRbVtWq9V47bXXjBo1ahheXl7GjTfeaPz444+ZTjnuaJrk9GmLz50757Cd6VNmG0bmU7FfP4329dMoG0batPHjx483QkJCDB8fH+O2224z9u7da5QvX9549NFHc3TsEhISjLffftto2bKl4e/vb3h6ehp16tQxnnzySePgwYN2db/88kujVq1ahqenp9GsWTNjxYoVuTou6WJjYw0fHx9DkvHll186rBMXF2eMGzfOqF27tuHp6WlUqFDBuOWWW4y3337bSE5OznKfMpsa3WKxGJMnTzZq1qxpeHh4GNWqVTPGjRtnJCYm2tWrUaNGllNkO3q9a/ubr6+vERYWZvTr189YsGCBkZqa6nC91atXGxEREUZgYKDh7e1thIeHG8OGDTO2bt1qV+/PP/80+vTpYwQFBRne3t5GvXr1jPHjx9uev75fbd++3Rg8eLBRvXp1w8vLy6hUqZJx5513ZtiurptCPH3diIgIw9/f3/D19TVuvfVW47fffrOrk5s+mp3MpmLP7Pjnpl989NFHRvPmzQ0fHx+jTJkyRuPGjY3nn3/eOHXqVI7atm3bNmPIkCFG5cqVDQ8PD6Ns2bJG586djTlz5ti9p9cfx0uXLhnDhw83KlSoYPj7+xsRERHGvn37MnzWX3nlFaNVq1ZGUFCQ4ePjY9SvX9949dVXbftx/vx544knnjDq169v+Pn5GYGBgUbr1q2N+fPn27Uzr1Oxp9uxY4fRt29fo3z58oaXl5dRo0YNY8CAAcaqVatsdTL7nQagcJkMgzvMAUBhiomJUdmyZfXKK6/ov//9r6ubAwAAnIRrrgCgAF29ejVDWfo1RZ06dSrcxgAAgALFNVcAUIDmzZun2bNnq0ePHvL399f69ev1zTffqFu3bmrbtq2rmwcAAJyIcAUABahJkyZyd3fXm2++qdjYWNskF1ldbA8AAIonrrkCAAAAACfgmisAAAAAcALCFQAAAAA4AddcOWC1WnXq1CmVKVMmRzf5BAAAAFAyGYahuLg4Va5cWW5uWY9NEa4cOHXqlKpVq+bqZgAAAAAoIk6cOKGqVatmWYdw5UCZMmUkpR3AgIAAF7em9LFYLFq5cqW6desmDw8PVzcHRRB9BNmhjyAn6CfIDn0EkhQbG6tq1arZMkJWCFcOpJ8KGBAQQLhyAYvFIl9fXwUEBPCLDA7RR5Ad+ghygn6C7NBHcK2cXC7EhBYAAAAA4ASEKwAAAABwAsIVAAAAADgB4QoAAAAAnIBwBQAAAABOQLgCAAAAACcgXAEAAACAExCuAAAAAMAJCFcAAAAA4ASEKwAAAABwAsIVAAAAADiBS8PVr7/+qp49e6py5coymUxasmRJtuusWbNGN910k7y8vFS7dm3Nnj07Q50PPvhAYWFh8vb2VuvWrbV582bnNx4AAAAAruHScBUfH6+mTZvqgw8+yFH9I0eO6I477tCtt96qnTt3avTo0XrooYe0YsUKW5158+ZpzJgxmjhxorZv366mTZsqIiJCZ8+eLajdAAAAAAC5u/LFb7/9dt1+++05rj9z5kzVrFlTU6ZMkSQ1aNBA69ev1zvvvKOIiAhJ0tSpUzVixAgNHz7cts7SpUs1a9YsjR071vk7AZQkqanSunXS6dNSaKjUvr1kNru6VQAAAMWCS8NVbm3cuFFdunSxK4uIiNDo0aMlScnJydq2bZvGjRtne97NzU1dunTRxo0bM91uUlKSkpKSbI9jY2MlSRaLRRaLxYl7gJxIP+b5OvapqTKtX28LCUa7doSEbJgWL5Z5zBiZTp60lRlVqih16lQZffq4sGUZOaWPoESjjyAn6CfIDn0EUu7e/2IVrs6cOaPg4GC7suDgYMXGxurq1au6dOmSUlNTHdbZt29fptuNjIzU5MmTM5SvXLlSvr6+zmk8ci0qKipP64Vu3KjGn3winwsXbGVXy5fXHw89pNNt2jireSVK6MaNavnGGxmfOHlS5oEDteU//ymSxy6vfQSlB30EOUE/QXboI6VbQkJCjusWq3BVUMaNG6cxY8bYHsfGxqpatWrq1q2bAgICXNiy0slisSgqKkpdu3aVh4dHrtY1LV4s85tvSoZhV+598aJavvmmUufOLXKjME5ntUoWS7aLKSUl7efERJk//VSSZLpuUyZJhsmkll99pZRJk4rM6F9++ghKB/oIcoJ+guzQRyD9e1ZbThSrcBUSEqLo6Gi7sujoaAUEBMjHx0dms1lms9lhnZCQkEy36+XlJS8vrwzlHh4efJBcKNfHPzVVeuaZDMFKkkyGIZlMcn/2WalfP/uQYBhp6+YgkGS6pAeVorBYrU44+tcdu3/+kccNN0i1a0shIVJwcNpy/c/lykluhTdPDp9RZIc+gpygnyA79JHSLTfvfbEKV23atNGyZcvsyqKiotTm/09X8vT0VPPmzbVq1Sr17t1bkmS1WrVq1SqNHDmysJsLZzEMKTFRunw58yUmRvrrL+mff7LezokTaQHAZLIPJCWd2Sx5eDherl6VzpzJfhuHDqUtWXF3lypW/Dd0ZRfETNePlQEAABRfLg1XV65c0cGDB22Pjxw5op07d6pcuXKqXr26xo0bp5MnT+rzzz+XJD366KN6//339fzzz+uBBx7QL7/8ovnz52vp0qW2bYwZM0ZDhw5VixYt1KpVK02bNk3x8fG22QOLlZIyc5ujYBQTk2lQMsfEqOPx42mjTOn1nBmAcjq0m1kYKajF3b3gtpvVaNKaNdKtt2Z/PF5/XapUSYqOTgtj0dH2P1+8mDaCd/p02pIdd/d/w1ZmQSz937JlCWIAAKDIc2m42rp1q2695ktd+nVPQ4cO1ezZs3X69GkdP37c9nzNmjW1dOlSPf3005o+fbqqVq2qTz75xDYNuyQNHDhQ586d04QJE3TmzBk1a9ZMy5cvzzDJRZG3aJE0apT9SEzVqtL06VLfvoXXjqSkbMNQtqEpOTlXL+kmKcjREyaTFBAgBQY6XmJipG++yf4FZs2Sbrkl60BiNpeeL/Pt26f1rZMnHZ5SKZMp7flnn8063CcnS2fPZgxdjoLYpUtpQezkybQlOx4edkHMXKmSGsTFye3wYalyZfsgFhRU+O9dSflDCAAAyBeTYTj6NlW6xcbGKjAwUJcvX3bNhBaLFkn9+2f8opv+hXHBgpwFrPRglJsgdP1yzRT1+WIySWXK/BuEgoIyDUkpfn7aeuCAWnTuLPfy5f+t6++f9QhMaqoUFpZ9SDhyhC++10vvc5L9scttn8uppKR/g5ij8HXtzzExudu2p2fWo2HX/hwYmP8gVlT+EAI7FotFy5YtU48ePbhOApminyA79BFIucsGxeqaq1IhNTXti5qjcJBe9uCD0q5dUlxc1qHJWcFIynrEKAeBSWXK5HiiA8NiUfSyZTLatk0bscgpszntC23//mlfmB2FhGnTCFaO9O2bFqAchYRp05wfEry8pGrV0pbsJCZmCGKpp07p2KZNCvPxkdu1o2XpI6UnTqQtOWlHTk5LDA5O+wxcH8Qy+0PIyZNp5c4OpSUNI34AgBKGcFXUrFuX9aQMUlp4eumlnG/z2hGjnAQhR8GouHzhKeyQUJL07Sv16lX0vux6e0vVq6ct/89qseiPZctUrUcPuV0bwBMTc3ZaYnR02rV3SUnS8eNpS07acW34qlhRmj8/8z+EmExp/bBnz9z9kaC0YMQPAFACEa6KmpxMBCBJnTtLzZtnH5qKUzBylqIaEooDs1nq1MnVrcg7b2+pRo20JTtXr+bstMQzZ6QrV9KC27FjaUtO/P8U9vL0TFu8vbNffHxyVi839T09i971g4z4AQBKKMJVURMamrN6L75YvL8EF7TiHhJQ8Hx80q7RCwvLvm5CQsbwFRUlLVyYs9dKTk5bcnETQqcqqOCWk7ru1/03k92pzyaTNHp02h9I+IMIAKCYIVwVNTmdua19+8JvG1Ba+fpKNWumLenq1ctZuFq8OG2UOTEx6+Xq1ezr5KbutRyVFRaz2T5sGYZ06lTm9dPvR/f662m3CKhYUapQIW0kvhBvUI0S6vrr/G6+2dUtAlDCEK6KGiZlAIqHnP4hpGfPwv+8GkbaSFlegpsz6l97X7rUVCk+Pm3JjRdftH9sNkvly6cFrfQlPXg5WoKCHL8vKL0cXOfnXqWKQu+9V+rRw4UNA1CSEK6KIiZlAIq+ovyHEJMpbSZEL6+0EZ/ClpqaNlmIoyC2YYP01FPZb6NevbSAeP582syoqalps0aePZujJnhIutPTU26VKmUMXlmFMk/P/O17YWGmxdzJ7Dq/U6fU8o03lHrTTdKAAa5pG4AShXBVVDEpA1D08YcQx8zmtFMpfX0zPte0qfTmm9mP+P3117+/75KSpAsX0oLWuXNp/zpa0p87d05KTpY5OTntfcluBtZrBQRkHrwchbKyZQv/9zIzLeZMSkraqOqVK9LIkQ77m8kwZEgyP/OM1K8f/8cCyDfCVVHGpAxA0ccfQnInLyN+Xl5S5cppS04YhiwxMVr97be6rUkTucfEZB/KLlyQrNa0SUdiY6XDh3P2WiaTVK5c9iNi1z5XpkzeZ3AsrjMtWiz/nj569ar9UlBlKSk5appJSguqAQFp72WZMmk/BwTk7Wdv76I3Q2d+MVIK5BjhCgDyiz+E5E5Bj/iZTJK/v64GB8to3jxn9xmzWtPuIZjViNj1S0xMWsi5cCFt2b8/Z+3z8MjZaYrXlnt7O2emRcP4d0Qnu5DizOCTmpqzY+NKCQlpS365u+c9mF3/c1G4Rx4jpflDMC11CFcAgMJX1Eb83NzSRi3KlZPq1s3ZOhbLv6cr5jSUJSSkrXf6dM7vayhJfn6Sv3/abQAykz7TYvPmaWEss9Bjteb8dQvCtdP3+/jYL84sS3/8++9p94bMzuefSw0b/jt6GReXu5+vXEnbTkqKdPFi2uKMY+WMkObvn7fPVnEdKS0qCKalEuEKAOAaxX3Ez8NDCglJW3IqISEtkOXk2rH0JSUldzMu7tqV8/YUZKhxVOblVfhT6nfsmOXMnoYkVa0q05Ah+Qv3VmtawLo2dOU2oKX/fPVq2jbTJ4I5dy7v7Urn55fzMFamTFr9xx7jnnR5RTDNn2I84ke4AgCgsKRP9FGtWs7qG0bal+3z56UVK6Qnnsh+nfHjpRYtchZ0Stq1QY5kcZ2f8f+PU6dMkXt+v7i5uf0bUvIrJSXvwez6n9NvjZAe0HMzYpqV9JFSb++0WTbd3bNePDyyr1MU1zEMeVy5knZMfXz+Lc/qs8PN0vOnmI/4Ea4AACiqTKa06fQDA6VHHpEiI7OfaXHiRL6wXS+z6/yqVNGWe+7RjX36uK5tjri7p81EWbZs/reVlJS3YHb4sHTwYPbbT0nJ8eQhxZGHJId3QXNzyzyUpaTk7BTedu3SRr49PP7dVvrPuX2cn3Wvf2w2u+4PLyVgxI9wBQBAcVCU761WHDi4zi/l5pt1esUK3ejqthUkL6+0yVEqVszdemvWSLfemn29+fOlli3/DVkWy78/Z7fkpq6rtp3ZNYpWa1pwTUrK3XG91u+/533dglZQwS2rx2az9MorxX7Ej3AFAEBxwb3V8uf66/zST5lDRu3bZ3mtmm2ktG/fIv1FN78sSUn66ccfdXvXrvIwmXIW3DZtkh5/PPuNP/usFB7+7/Ysln+XrB47u64j6fuSfv1fUZA+4rduXZG+XpdwBQBAcVLUZlpEycRIaRo3Nxnu7mnXW+V0avymTaXXXss+mL7+uuuPn2GkXSPm6oBnsUgHDki//ZZ9m5113WABIVwBAFDcFPeZFlE8MFKaN8UpmJpM/14r5mo5PRU1NLTAm5IfhTwfKgAAAIqNvn2lo0el1aulr79O+/fIEYJVdtKDaZUq9uVVqxaLSRlcIv1U1Mwm0zCZ0mZabd++cNuVS0UgpgIAAKDIYqQ0bziFN3eK04hfFghXAAAAQEEgmOZOCTgVlXAFAAAAoGgo5iN+hCsAAAAARUcxHvFjQgsAAAAAcALCFQAAAAA4AeEKAAAAAJyAcAUAAAAATkC4AgAAAAAnIFwBAAAAgBMQrgAAAADACQhXAAAAAOAEhCsAAAAAcALCFQAAAAA4AeEKAAAAAJyAcAUAAAAATkC4AgAAAAAnIFwBAAAAgBMQrgAAAADACQhXAAAAAOAEhCsAAAAAcALCFQAAAAA4AeEKAAAAAJyAcAUAAAAATkC4AgAAAAAnIFwBAAAAgBMQrgAAAADACQhXAAAAAOAEhCsAAAAAcALCFQAAAAA4AeEKAAAAAJyAcAUAAAAATkC4AgAAAAAnIFwBAAAAgBO4PFx98MEHCgsLk7e3t1q3bq3NmzdnWtdiseill15SeHi4vL291bRpUy1fvtyuzqRJk2QymeyW+vXrF/RuAAAAACjlXBqu5s2bpzFjxmjixInavn27mjZtqoiICJ09e9Zh/RdffFH/+9//9N5772nPnj169NFH1adPH+3YscOuXqNGjXT69Gnbsn79+sLYHQAAAAClmEvD1dSpUzVixAgNHz5cDRs21MyZM+Xr66tZs2Y5rP/FF1/ohRdeUI8ePVSrVi099thj6tGjh6ZMmWJXz93dXSEhIbalQoUKhbE7AAAAAEoxd1e9cHJysrZt26Zx48bZytzc3NSlSxdt3LjR4TpJSUny9va2K/Px8ckwMnXgwAFVrlxZ3t7eatOmjSIjI1W9evVM25KUlKSkpCTb49jYWElppyFaLJZc7xvyJ/2Yc+yRGfoIskMfQU7QT5Ad+gik3L3/JsMwjAJsS6ZOnTqlKlWq6LffflObNm1s5c8//7zWrl2rTZs2ZVhnyJAh2rVrl5YsWaLw8HCtWrVKvXr1Umpqqi0c/fTTT7py5Yrq1aun06dPa/LkyTp58qT+/PNPlSlTxmFbJk2apMmTJ2co//rrr+Xr6+ukPQYAAABQ3CQkJGjIkCG6fPmyAgICsqxbrMLVuXPnNGLECP3www8ymUwKDw9Xly5dNGvWLF29etXh68TExKhGjRqaOnWqHnzwQYd1HI1cVatWTefPn8/2AML5LBaLoqKi1LVrV3l4eLi6OSiC6CPIDn0EOUE/QXboI5DSskGFChVyFK5cdlpghQoVZDabFR0dbVceHR2tkJAQh+tUrFhRS5YsUWJioi5cuKDKlStr7NixqlWrVqavExQUpLp16+rgwYOZ1vHy8pKXl1eGcg8PDz5ILsTxR3boI8gOfQQ5QT9BdugjpVtu3nuXTWjh6emp5s2ba9WqVbYyq9WqVatW2Y1kOeLt7a0qVaooJSVFCxcuVK9evTKte+XKFR06dEihoaFOazsAAAAAXM+lswWOGTNGH3/8sebMmaO9e/fqscceU3x8vIYPHy5Juv/+++0mvNi0aZMWLVqkw4cPa926derevbusVquef/55W51nn31Wa9eu1dGjR/Xbb7+pT58+MpvNGjx4cKHvHwAAAIDSw2WnBUrSwIEDde7cOU2YMEFnzpxRs2bNtHz5cgUHB0uSjh8/Lje3f/NfYmKiXnzxRR0+fFj+/v7q0aOHvvjiCwUFBdnq/PPPPxo8eLAuXLigihUrql27dvr9999VsWLFwt49AAAAAKWIS8OVJI0cOVIjR450+NyaNWvsHnfs2FF79uzJcntz5851VtMAAAAAIMdcelogAAAAAJQUhCsAAAAAcALCFQAAAAA4AeEKAAAAAJyAcAUAAAAATkC4AgAAAAAnIFwBAAAAgBMQrgAAAADACQhXAAAAAOAEhCsAAAAAcALCFQAAAAA4AeEKAAAAAJyAcAUAAAAATkC4AgAAAAAnIFwBAAAAgBMQrgAAAADACQhXAAAAAOAEhCsAAAAAcALCFQAAAAA4AeEKAAAAAJyAcAUAAAAATkC4AgAAAAAnIFwBAAAAgBMQrgAAAADACQhXAAAAAOAEhCsAAAAAcALCFQAAAAA4AeEKAAAAAJyAcAUAAAAATkC4AgAAAAAnIFwBAAAAgBMQrgAAAADACQhXAAAAAOAEhCsAAAAAcALCFQAAAAA4AeEKAAAAAJyAcAUAAAAATkC4AgAAAAAnIFwBAAAAgBMQrgAAAADACQhXAAAAAOAEhCsAAAAAcALCFQAAAAA4AeEKAAAAAJyAcAUAAAAATkC4AgAAAAAnIFwBAAAAgBMQrgAAAADACQhXAAAAAOAEhCsAAAAAcALCFQAAAAA4AeEKAAAAAJyAcAUAAAAATuDycPXBBx8oLCxM3t7eat26tTZv3pxpXYvFopdeeknh4eHy9vZW06ZNtXz58nxtEwAAAACcwaXhat68eRozZowmTpyo7du3q2nTpoqIiNDZs2cd1n/xxRf1v//9T++995727NmjRx99VH369NGOHTvyvE0AAAAAcAaXhqupU6dqxIgRGj58uBo2bKiZM2fK19dXs2bNclj/iy++0AsvvKAePXqoVq1aeuyxx9SjRw9NmTIlz9sEAAAAAGdwd9ULJycna9u2bRo3bpytzM3NTV26dNHGjRsdrpOUlCRvb2+7Mh8fH61fvz7P20zfblJSku1xbGyspLTTEC0WS+53DvmSfsw59sgMfQTZoY8gJ+gnyA59BFLu3n+Xhavz588rNTVVwcHBduXBwcHat2+fw3UiIiI0depUdejQQeHh4Vq1apUWLVqk1NTUPG9TkiIjIzV58uQM5StXrpSvr29udw1OEhUV5eomoIijjyA79BHkBP0E2aGPlG4JCQk5ruuycJUX06dP14gRI1S/fn2ZTCaFh4dr+PDh+T7lb9y4cRozZoztcWxsrKpVq6Zu3bopICAgv81GLlksFkVFRalr167y8PBwdXNQBNFHkB36CHKCfoLs0Ecg/XtWW064LFxVqFBBZrNZ0dHRduXR0dEKCQlxuE7FihW1ZMkSJSYm6sKFC6pcubLGjh2rWrVq5XmbkuTl5SUvL68M5R4eHnyQXIjjj+zQR5Ad+ghygn6C7NBHSrfcvPcum9DC09NTzZs316pVq2xlVqtVq1atUps2bbJc19vbW1WqVFFKSooWLlyoXr165XubAAAAAJAfLj0tcMyYMRo6dKhatGihVq1aadq0aYqPj9fw4cMlSffff7+qVKmiyMhISdKmTZt08uRJNWvWTCdPntSkSZNktVr1/PPP53ibAAAAAFAQXBquBg4cqHPnzmnChAk6c+aMmjVrpuXLl9smpDh+/Ljc3P4dXEtMTNSLL76ow4cPy9/fXz169NAXX3yhoKCgHG8TAAAAAAqCyye0GDlypEaOHOnwuTVr1tg97tixo/bs2ZOvbQIAAABAQXDpTYQBAAAAoKQgXAEAAACAExCuAAAAAMAJCFcAAAAA4ASEKwAAAABwAsIVAAAAADgB4QoAAAAAnIBwBQAAAABOQLgCAAAAACcgXAEAAACAExCuAAAAAMAJCFcAAAAA4ASEKwAAAABwAsIVAAAAADgB4QoAAAAAnIBwBQAAAABOQLgCAAAAACcgXAEAAACAExCuAAAAAMAJCFcAAAAA4ASEKwAAAABwAsIVAAAAADgB4QoAAAAAnIBwBQAAAABOQLgCAAAAACcgXAEAAACAExCuAAAAAMAJCFcAAAAA4ASEKwAAAABwAsIVAAAAADgB4QoAAAAAnIBwBQAAAABOQLgCAAAAACcgXAEAAACAExCuAAAAAMAJCFcAAAAA4ASEKwAAAABwAsIVAAAAADgB4QoAAAAAnIBwBQAAAABOQLgCAAAAACcgXAEAAACAExCuAAAAAMAJCFcAAAAA4ASEKwAAAABwAsIVAAAAADgB4QoAAAAAnIBwBQAAAABOQLgCAAAAACcgXAEAAACAExCuAAAAAMAJCFcAAAAA4ASEKwAAAABwApeHqw8++EBhYWHy9vZW69attXnz5izrT5s2TfXq1ZOPj4+qVaump59+WomJibbnJ02aJJPJZLfUr1+/oHcDAAAAQCnn7soXnzdvnsaMGaOZM2eqdevWmjZtmiIiIrR//35VqlQpQ/2vv/5aY8eO1axZs3TLLbfo77//1rBhw2QymTR16lRbvUaNGunnn3+2PXZ3d+luAgAAACgFXDpyNXXqVI0YMULDhw9Xw4YNNXPmTPn6+mrWrFkO6//2229q27athgwZorCwMHXr1k2DBw/OMNrl7u6ukJAQ21KhQoXC2B0AAAAApZjLhnSSk5O1bds2jRs3zlbm5uamLl26aOPGjQ7XueWWW/Tll19q8+bNatWqlQ4fPqxly5bpvvvus6t34MABVa5cWd7e3mrTpo0iIyNVvXr1TNuSlJSkpKQk2+PY2FhJksVikcViyc9uIg/SjznHHpmhjyA79BHkBP0E2aGPQMrd+++ycHX+/HmlpqYqODjYrjw4OFj79u1zuM6QIUN0/vx5tWvXToZhKCUlRY8++qheeOEFW53WrVtr9uzZqlevnk6fPq3Jkyerffv2+vPPP1WmTBmH242MjNTkyZMzlK9cuVK+vr752EvkR1RUlKubgCKOPoLs0EeQE/QTZIc+UrolJCTkuG6xuhhpzZo1eu211/Thhx+qdevWOnjwoEaNGqWXX35Z48ePlyTdfvvttvpNmjRR69atVaNGDc2fP18PPvigw+2OGzdOY8aMsT2OjY1VtWrV1K1bNwUEBBTsTiEDi8WiqKgode3aVR4eHq5uDoog+giyQx9BTtBPkB36CKR/z2rLCZeFqwoVKshsNis6OtquPDo6WiEhIQ7XGT9+vO677z499NBDkqTGjRsrPj5eDz/8sP773//KzS3jJWRBQUGqW7euDh48mGlbvLy85OXllaHcw8ODD5ILcfyRHfoIskMfQU7QT5Ad+kjplpv33mUTWnh6eqp58+ZatWqVrcxqtWrVqlVq06aNw3USEhIyBCiz2SxJMgzD4TpXrlzRoUOHFBoa6qSWAwAAAEBG+QpXycnJ2r9/v1JSUvK0/pgxY/Txxx9rzpw52rt3rx577DHFx8dr+PDhkqT777/fbsKLnj17asaMGZo7d66OHDmiqKgojR8/Xj179rSFrGeffVZr167V0aNH9dtvv6lPnz4ym80aPHhwfnYVAAAAALKUp9MCExIS9OSTT2rOnDmSpL///lu1atXSk08+qSpVqmjs2LE52s7AgQN17tw5TZgwQWfOnFGzZs20fPly2yQXx48ftxupevHFF2UymfTiiy/q5MmTqlixonr27KlXX33VVueff/7R4MGDdeHCBVWsWFHt2rXT77//rooVK+ZlVwEAAAAgR/IUrsaNG6ddu3ZpzZo16t69u628S5cumjRpUo7DlSSNHDlSI0eOdPjcmjVr7Bvr7q6JEydq4sSJmW5v7ty5OX5tAAAAAHCWPIWrJUuWaN68ebr55ptlMpls5Y0aNdKhQ4ec1jgAAAAAKC7ydM3VuXPnVKlSpQzl8fHxdmELAAAAAEqLPIWrFi1aaOnSpbbH6YHqk08+yXSmPwAAAAAoyfJ0WuBrr72m22+/XXv27FFKSoqmT5+uPXv26LffftPatWud3UYAAAAAKPLyNHLVrl077dq1SykpKWrcuLFWrlypSpUqaePGjWrevLmz2wgAAAAARV6uR64sFoseeeQRjR8/Xh9//HFBtAkAAAAAip1cj1x5eHho4cKFBdEWAAAAACi28nRaYO/evbVkyRInNwUAAAAAiq88TWhRp04dvfTSS9qwYYOaN28uPz8/u+efeuoppzQOAAAAAIqLPIWrTz/9VEFBQdq2bZu2bdtm95zJZCJcAQAAACh18hSujhw54ux2AAAAAECxlqdrrq5lGIYMw3BGWwAAAACg2MpzuPr888/VuHFj+fj4yMfHR02aNNEXX3zhzLYBAAAAQLGRp9MCp06dqvHjx2vkyJFq27atJGn9+vV69NFHdf78eT399NNObSQAAAAAFHV5ClfvvfeeZsyYofvvv99Wdtddd6lRo0aaNGkS4QoAAABAqZOn0wJPnz6tW265JUP5LbfcotOnT+e7UQAAAABQ3OQpXNWuXVvz58/PUD5v3jzVqVMn340CAAAAgOImT6cFTp48WQMHDtSvv/5qu+Zqw4YNWrVqlcPQBQAAAAAlXZ5Grvr166dNmzapQoUKWrJkiZYsWaIKFSpo8+bN6tOnj7PbCAAAAABFXp5GriSpefPm+vLLL53ZFgAAAAAotvI0crVs2TKtWLEiQ/mKFSv0008/5btRAAAAAFDc5ClcjR07VqmpqRnKDcPQ2LFj890oAAAAAChu8hSuDhw4oIYNG2Yor1+/vg4ePJjvRgEAAABAcZOncBUYGKjDhw9nKD948KD8/Pzy3SgAAAAAKG7yFK569eql0aNH69ChQ7aygwcP6plnntFdd93ltMYBAAAAQHGRp3D15ptvys/PT/Xr11fNmjVVs2ZN1a9fX+XLl9fbb7/t7DYCAAAAQJGXp6nYAwMD9dtvvykqKkq7du2Sj4+PmjZtqvbt2zu7fQAAAABQLORq5Grjxo368ccfJUkmk0ndunVTpUqV9Pbbb6tfv356+OGHlZSUVCANBQAAAICiLFfh6qWXXtJff/1le/zHH39oxIgR6tq1q8aOHasffvhBkZGRTm8kAAAAABR1uQpXO3fuVOfOnW2P586dq1atWunjjz/WmDFj9O6772r+/PlObyQAAAAAFHW5CleXLl1ScHCw7fHatWt1++232x63bNlSJ06ccF7rAAAAAKCYyFW4Cg4O1pEjRyRJycnJ2r59u26++Wbb83FxcfLw8HBuCwEAAACgGMhVuOrRo4fGjh2rdevWady4cfL19bWbIXD37t0KDw93eiMBAAAAoKjL1VTsL7/8svr27auOHTvK399fc+bMkaenp+35WbNmqVu3bk5vJAAAAAAUdbkKVxUqVNCvv/6qy5cvy9/fX2az2e75b7/9Vv7+/k5tIAAAAAAUB3m+ibAj5cqVy1djAAAAAKC4ytU1VwAAAAAAxwhXAAAAAOAEhCsAAAAAcALCFQAAAAA4AeEKAAAAAJyAcAUAAAAATkC4AgAAAAAnIFwBAAAAgBMQrgAAAADACQhXAAAAAOAEhCsAAAAAcALCFQAAAAA4AeEKAAAAAJyAcAUAAAAATkC4AgAAAAAnIFwBAAAAgBMQrgAAAADACVwerj744AOFhYXJ29tbrVu31ubNm7OsP23aNNWrV08+Pj6qVq2ann76aSUmJuZrmwAAAACQXy4NV/PmzdOYMWM0ceJEbd++XU2bNlVERITOnj3rsP7XX3+tsWPHauLEidq7d68+/fRTzZs3Ty+88EKetwkAAAAAzuDScDV16lSNGDFCw4cPV8OGDTVz5kz5+vpq1qxZDuv/9ttvatu2rYYMGaKwsDB169ZNgwcPthuZyu02AQAAAMAZ3F31wsnJydq2bZvGjRtnK3Nzc1OXLl20ceNGh+vccsst+vLLL7V582a1atVKhw8f1rJly3TffffleZuSlJSUpKSkJNvj2NhYSZLFYpHFYsnXfiL30o85xx6ZoY8gO/QR5AT9BNmhj0DK3fvvsnB1/vx5paamKjg42K48ODhY+/btc7jOkCFDdP78ebVr106GYSglJUWPPvqo7bTAvGxTkiIjIzV58uQM5StXrpSvr29udw1OEhUV5eomoIijjyA79BHkBP0E2aGPlG4JCQk5ruuycJUXa9as0WuvvaYPP/xQrVu31sGDBzVq1Ci9/PLLGj9+fJ63O27cOI0ZM8b2ODY2VtWqVVO3bt0UEBDgjKYjFywWi6KiotS1a1d5eHi4ujkogugjyA59BDlBP0F26COQ/j2rLSdcFq4qVKggs9ms6Ohou/Lo6GiFhIQ4XGf8+PG677779NBDD0mSGjdurPj4eD388MP673//m6dtSpKXl5e8vLwylHt4ePBBciGOP7JDH0F26CPICfoJskMfKd1y8967bEILT09PNW/eXKtWrbKVWa1WrVq1Sm3atHG4TkJCgtzc7JtsNpslSYZh5GmbAAAAAOAMLj0tcMyYMRo6dKhatGihVq1aadq0aYqPj9fw4cMlSffff7+qVKmiyMhISVLPnj01depU3XjjjbbTAsePH6+ePXvaQlZ22wQAAACAguDScDVw4ECdO3dOEyZM0JkzZ9SsWTMtX77cNiHF8ePH7UaqXnzxRZlMJr344os6efKkKlasqJ49e+rVV1/N8TYBAAAAoCC4fEKLkSNHauTIkQ6fW7Nmjd1jd3d3TZw4URMnTszzNgEAAACgILj0JsIAAAAAUFIQrgAAAADACQhXAAAAAOAEhCsAAAAAcALCFQAAAAA4AeEKAAAAAJyAcAUAAAAATkC4AgAAAAAnIFwBAAAAgBMQrgAAAADACQhXAAAAAOAEhCsAAAAAcALCFQAAAAA4AeEKAAAAAJyAcAUAAAAATkC4AgAAAAAnIFwBAAAAgBMQrgAAAADACQhXAAAAAOAEhCsAAAAAcALCFQAAAAA4AeEKAAAAAJyAcAUAAAAATkC4AgAAAAAnIFwBAAAAgBMQrgAAAADACQhXAAAAAOAE7q5uAAAAQGFItaZq3fF1Oh13WqFlQnVz6M2ubhKAEoZwBQAASrxFexdp1PJR+if2H1tZlTJVdG/5e9VDPVzYMgAlCacFAgCAEm3R3kXqP7+/XbCSpFNxp/TG0Te0eN9iF7UMQElDuAIAACVWqjVVo5aPkiEjw3PpZc/8/IxSramF3TQAJRDhCgAAlEin4k4pcn1khhGr6/0T+49e+fUV/XX2LyWnJhdS6wCURFxzBQAAir2LVy9q66mt2nJyi7acSltOxZ3K8fqT1k7SpLWTZDaZFV4uXA0qNFCDCg3UsGJDNajYQPUr1Je/p38B7gGAkoBwBQAAipX45HhtP73dFqK2nNyiQ5cOZajnZnJTjcAaOhJzJNttNqjQQCfjTio2KVZ/X/hbf1/4W9/t/86uTrWAampQ8ZrQVaGBGlRsoAq+FZy2bwCKN8IVAAAospJTk7U7erfdiNSec3tkNawZ6tYuV1stK7dMW6q01I0hN8rb3Vth08N0Mvakw+uuJKlqQFX98dgfcjO56VTcKe09v1d7z+1N+/f/f46Oj9aJ2BM6EXtCKw+ttFu/gm+FDCNdDSo0UNWAqjKZTAVyXAAUTYQrAABQJKRaU7Xv/D7baNSWU1u0K3qXw+ugqpSpopZVWtrCVIvKLVTWp6zD7U7vPl395/eXSSa7gJX+eEqXKTK7mdO2G1BFVQKqqEutLnbbuHj14r+B65rgdTTmqM4nnNe64+u07vg6u3X8Pf1Vv0L9DMGrVtlacnfjKxhQEvHJBgAAhc4wDB2JOWI3IrX99HZdSb6SoW45n3J2I1ItK7dUaJnQHL9W3wZ9tWDAgoz3uQqoonvK3aM+9ftku41yPuXUtnpbta3e1q48Pjle+y/szzDSdeDiAV1JvqKtp7Zq66mtdut4mj1Vp1ydDKcY1i1fVz4ePjneLwBFD+EKAAAUuNNxp+1GpLae2qoLVy9kqOfn4afmlZvbhamaQTXzfXpd3wZ91ateL607vk6n404rtEyobg69WSuWr8jXdv08/XRT6E26KfQmu3JLqkUHLx7MMNK17/w+JVgS9Ne5v/TXub/s1jHJpJplazo8xTDQOzBf7QRQOAhXAADAqS5dvZQ2c981E06cjDuZoZ6n2VNNg5vajUjVr1Dfdoqes5ndzOoU1sn22GKxFMjrSJKH2SMtGFVsIDX4t9xqWHX88nGHpxhevHpRhy8d1uFLh7X0wFK77YX6h9qC1rXBK9gvmOu6gCKEcAUAAPIsPjleO87ssDu97+DFgxnquZnc1LBiQ7sRqcaVGsvL3csFrXYdN5ObwoLCFBYUptvr3G4rNwxD5xLOac+5PRlOMTwZd1Knr5zW6Sun9cuRX+y2F+QdZAtcDSr+e4phjaAacjM553amqdZUuxG/9tXbF1gABoo7whUAAMiR5NRk/RH9h93pfX+d+8vhzH3hZcPtJpy4MfRG7hOVBZPJpEp+lVTJr5Ld6JokXU68rH3n92UY6Tp86bBiEmO08Z+N2vjPRrt1fNx9VK9CvQwjXbXL1Zan2TPH7Vq0d1GGa9WqBlTV9O7T1bdB33ztM1ASEa4AAEAGqdZU7b+w325EateZXUpKTcpQt3KZynYjUi0qt1A5n3IuaHXJFOgdqNZVW6t11dZ25YkpiTpw4UDaaNc1I137L+zX1ZSr2nlmp3ae2Wm3jtlkVu1ytTOcYli/Qn35efrZ1V20d5H6z++fYQr7k7En1X9+fy0YsICAlQ1G/UofwhUAAKWcYRg6GnPUbkRq2+ltDmfuK+td1m5EqmWVlqpcprILWg1vd281Dm6sxsGN7cpTrak6EnPE4SmGcclx2n9hv/Zf2K8lWmK3XvXA6rbAVa9CPU1YPcHhvcEMGTLJpNHLR6tXvV6EhUww6lc6Ea4AAChm8vvX8DNXztiNSG09tVXnE85nqOfr4avmoc3tJpyoVbYWEygUcWa3tNGp2uVq6656d9nKDcPQqbhT/450XRO8zsaf1fHLx3X88nGtOJT9DIqGDJ2IPaEHv39QdcvXlafZM8eLh5tHtnWKe2Bj1K/0IlwBAFCM5Pav4TGJMWkz910Tpq5dN52Hm4eahjS1G5FqUKFBsf+Si3+ZTCbbTZK7hne1ey79JsnpwWvVkVXaHb07223O2TWnQNrqZnJzWlDLzzbcDDcdvXpU+y/sl5+XX46CYKo1VaOWj2LUr5QiXAEAUExk99fwr/p+peqB1e2mQD9w8UCG7ZhkSpu575rT+5oENyl1M/fhX9ffJHnN0TW6dc6t2a53V927VNGvopJTkx0uFqsl0+euXVKsKXbbtRpWJaYkKjElsUD2N9f2Z/5UehBMD2mGYehi4sVM66eP+t2/+H41qtRI/p7+mS5+Hn5p/3r6yd2t9HxtL87XqpWedwkAgGIsu7+GS9KQRUMcrlurbC27EambQm9i5j5kqX319qoaUFUnY0867HMmmVQ1oKoWDVzklC+9VsMqS6rjIJbTgJbVYrdtay7WTUlW3NU4mdxNtm1YrJYMbU9MSVSichcEv/7z61zV93b3zjKI+Xtk8Vwmi6fZs8id5lvcr1UjXAEAUEQlpiTqyKUjOnTpkJYfXO7wdL7rlfMup3Y12tnCVIvKLVTet3whtBYlidnNrOndp6v//P4yyWQXsExK+zI+rfs0p40muJnc5OXuVeRGTy0Wi5YtW6YePXrIw8NDUtq1a1kFvt9O/KYRP4zIdtv9GvRTkHeQ4i3xupJ8xeESlxSnVCNVkmwjeY6uj8wrdzf3PAc2P08/h+W+Hr55vsdaSbhWjXAFAIALxSTG6NDFQzp06ZAOXTykgxcPpv186VCmowZZeb/H+xrceHABtRalSd8GfbVgwAKHowjTuk8r8l9yC4rJZLJdb+VIvfL1NHnt5GxH/eb1n5dtODUMQ8mpyZmGr0wXS9bPp59umWJNUUxijGISY/J9XK6VfjpjbhZfD1899dNTxf5aNcIVAAAFyDAMnb5y2i5AHbr0b4i6eDXzazMkKcArQOFlw1XGq4x+PfZrtq8XWibUWU0H1LdBX/Wq16vYXv/iCs4c9TOZTLYRPWeOQKdaU7McMcvrkr6v8ZZ4xVviFR0f7bQ2p1+rtu74ugw32i5KCFcAAOSTJdWiY5ePZQhQ6T9fTbma5foh/iEKLxuu8HLhaf/+/8+1y9VWeZ/yMplMSrWmKmx6WLZ/DW9fvX1B7SZKKbObuUh/mS2Kivqon9nNrACvAAV4BThtm4Zh6GrKVYehKz45iyD3/6NsBy8e1J5ze7J9ndNxp53W5oJAuAIAIAfik+N1+NLhf0/buyZAHYs5ZrsuwhGzyazqgdXTAlPZ2v+GqHLhqlW2Vo4mlyjsa2AA5E9pG/UzmUzy9fCVr4evKvlVyvX6OZ2hsqiPzhOuAABQ2l9dL1y9kOG0vfTHZ66cyXJ9H3cf1SpbyxacaperbQtQNQJryMPske82FvW/hgOwx6hfzuV0hsqiPjpfJMLVBx98oLfeektnzpxR06ZN9d5776lVq1YO63bq1Elr167NUN6jRw8tXbpUkjRs2DDNmWN/U7uIiAgtX77c+Y0HABQbVsOqf2L/sZ9A4tJB2+PYpNgs1y/nUy7D6Xu1y6WNRIX6hxbKlMal7a/hAEqHkjI67/JwNW/ePI0ZM0YzZ85U69atNW3aNEVERGj//v2qVCnjkOKiRYuUnJxse3zhwgU1bdpUd999t1297t2767PPPrM99vIqWlN7AkBpV1A3iUxKSdLf5//W1stbdXjLYR29fNQ2EnUk5oiSU5OzXL9KmSp2o07X/lvWp2y+2+cM/DUcQElUEkbnXR6upk6dqhEjRmj48OGSpJkzZ2rp0qWaNWuWxo4dm6F+uXLl7B7PnTtXvr6+GcKVl5eXQkJCCq7hAIA8y+9NIi8nXra/7uma659OXD7x7188j2Rc18PNQ2FBYQ6vf6oZVFM+Hj7O2k0AQC4V99F5l4ar5ORkbdu2TePGjbOVubm5qUuXLtq4cWOOtvHpp59q0KBB8vPzsytfs2aNKlWqpLJly+q2227TK6+8ovLlHU9hmZSUpKSkJNvj2Ni000IsFossFovDdVBw0o85xx6ZoY8Ub4v3LdagRYMyvUnk3L5z1bteb0XHR+vwpcM6FJMWng7HHNbhS2nL+atZ30TT38NfFcwV1LRaU4WXD1d4UFqAqlW2lqoFVMvyP2n6VenB7xJkhz7iOm2rtLX9bE21yppqdVlbcvP+mwzDyN3dCZ3o1KlTqlKlin777Te1adPGVv78889r7dq12rRpU5brb968Wa1bt9amTZvsrtFKH82qWbOmDh06pBdeeEH+/v7auHGjzOaM/6FOmjRJkydPzlD+9ddfy9fXNx97CAC4VqqRqof3PKwLlguZ1jHLLHeTu5KMpEzrSFKge6BCPEMU4hVi+zfUK1QhniEKdA8slOufAAAlX0JCgoYMGaLLly8rICDr6etdflpgfnz66adq3LhxhskvBg0aZPu5cePGatKkicLDw7VmzRp17tw5w3bGjRunMWPG2B7HxsaqWrVq6tatW7YHEM5nsVgUFRWlrl27ysMj/7NroeShjxRPlxMv67Ndn2UZrCQpValKNVLlZnJTtYBqqhVUyzbqlL6EB6XdVDcz9BHkBP0E2aGPQPr3rLaccGm4qlChgsxms6Kj7e/eHB0dne31UvHx8Zo7d65eeumlbF+nVq1aqlChgg4ePOgwXHl5eTmc8MLDw4MPkgvl5/gX1IXyKFr4jBZdVy1XtePMDm09tVVbTm3RlpNbtP/C/hyvP6XbFI1sNVKeZs98tYM+gpygnyA79JHSLTfvvUvDlaenp5o3b65Vq1apd+/ekiSr1apVq1Zp5MiRWa777bffKikpSffee2+2r/PPP//owoULCg0t2jcdg3Pk90J5ALljSbXoz7N/2kLUllNb9OfZPx3eVDfYL1jR8dEOtmLvptCb8h2sAAAobC4/LXDMmDEaOnSoWrRooVatWmnatGmKj4+3zR54//33q0qVKoqMjLRb79NPP1Xv3r0zTFJx5coVTZ48Wf369VNISIgOHTqk559/XrVr11ZERESh7RdcY9HeReo/v3+mF8ovGLCAgAXkg9Wwav/5/dpyaottVGrnmZ1KTEnMUDfYL1gtq7RUy8ppS4vKLVTOp5zCpocV+5tEAgDgiMvD1cCBA3Xu3DlNmDBBZ86cUbNmzbR8+XIFBwdLko4fPy43Nze7dfbv36/169dr5cqVGbZnNpu1e/duzZkzRzExMapcubK6deuml19+mXtdlXCp1lSNWj7K4Rc2Q4ZMMmn08tHqVa8XpwgCOWAYho5dPmYbjdpyaou2ndqmuOS4DHWDvIPUonILtQhtYQtUVQOqOpxUoiTcJBIAAEdcHq4kaeTIkZmeBrhmzZoMZfXq1VNmkxz6+PhoxYoVzmweiol1x9fZnQp4PUOGTsSe0Lrj67j5JuDAmStn7ILU1lNbdT4h45TnPu4+uin0prQRqf8PUuHlwuVmcnOw1YxKwk0iAQBwpEiEK8AZTsedzlG9k3EnC7glQNF36eolbTu9zS5MOfrjhIebh5oEN7EFqRaVW6hhxYZyd8vffx/F/SaRAAA4QrhCiRFaJmcTljy57EltOL5BfRv0VccaHeVhZvYflGzxyfHacWaHXZA6ePFghnommdSgYgPbNVItq7RUk+Am8nb3LpB2md3MjCIDAEoUwhVKjHbV2snXw1cJloRM65hk0qXES5qxdYZmbJ2hcj7ldFe9u9SvQT91rdVVXu5cl4fiLTk1Wbujd6dNNvH/Yeqvc3/JamS8s32tsrXsgtRNoTfJ39PfBa0GAKBkIFyhxJj6+9RMg1X6hfJz+89VGc8yWrR3kZbsX6LzCec1e+dszd45W2U8y+iOuneoX4N+6l67O18yUeSlWlO17/w+uynQd0XvUnJqcoa6lctUts3Yl/5ved/yDrYKAADyinCFEmHp30s19uexkqQRN43QTwd/yvJC+dvr3K4Z1hlaf3y9Fu5ZqEX7FulU3CnN/XOu5v45V97u3upeu7v61u+rnvV6Ksg7yBW7BdgYhqHDlw7bBantp7cr3hKfoW5Z77J2U6C3rNJSlctUdkGrAQAoXQhXKPb2nturwQsHy5ChR5o/ohl3zJDVsGZ7oby7m7s6hXVSp7BOmn77dG0+uVkL9yzUwr0LdSTmiJbsW6Il+5bI3c1dnWt2Vr8G/dS7fm9V9Kvooj1FaXIq7lSGmfsuXr2YoZ6fh5+aV25udy+pWmVrOZwCHQAAFCzCFYq1i1cv6q65dykuOU4danTQu7e/K5PJJLMpdxfKu5ncdHPVm3Vz1Zv1Ztc3tSt6lxbtXaSFexdqz7k9WnFohVYcWqFHlz6q9tXbq1+DfurToI+qBlQtuJ1DsZFqTc3XrHcXEi7YbsibHqROxZ3KUM/T7KmmwU3tpkCvX6E+M+wBAFBEEK5QbKVYUzRwwUAdvHhQNQJraMHdC+Rp9sz3dk0mk5qFNFOzkGZ66daXtO/8PlvQ2n56u9YeW6u1x9bqqeVPqXWV1urXoJ/6Nuir8HLhTtgrFDeL9i5yeL+m6d2nO7xf05XkK9p+ervdqNThS4cz1HMzualRxUZ2QapxcGOn9HEAAFAwCFcotp5d+ax+Pvyz/Dz89P3g7wvsdL36FerrhfYv6IX2L+hozFEt2rtIi/Yu0m8nftOmk5u06eQmPf/z82oa3FR9G/RVvwb91LBiQ07LKgUW7V2k/vP7y5D9Tc1Pxp5U//n99U2/b1SzbE27ILX33N4M9SWpTrk6afeRCm2hllVa6saQG+Xn6VdYuwIAAJyAcIVi6dPtn2r6pumSpM/7fK4mwU0K5XXDgsI0ps0YjWkzRqfjTmvJviVauHeh1hxdo13Ru7QrepcmrpmouuXr2ka0moc2J2iVQKnWVI1aPsphUEovG7RwkMN1qwZUtZtsonloc5X1KVug7QUAAAWPcIViZ8PxDXps6WOSpMmdJjs89aowhJYJ1WMtH9NjLR/ThYQL+n7/91q4d6GiDkfp7wt/K3J9pCLXR6pGYA31bdBXfRv01S3VbpGbyc0l7YXzXE68rDk759idCpiZAK8Ata3W9t9p0Ku0VIh/SCG0EgAAFDbCFYqV45ePq+/8vrJYLerfsL9e7PCiq5skSSrvW17Dbxyu4TcOV2xSrJb+vVSL9i3SsgPLdOzyMb3z+zt65/d3FOIfot71eqtfw37qWKOjPMwerm46smAYho5fPq6dZ3ZqV/Qu27+OrpHKzIw7ZmhI4yEF2EoAAFBUEK5QbMQnx6vX3F46G39WTYObanav2UVyFCjAK0CDGw/W4MaDlWBJ0MpDK7Vw70L9sP8HnblyRjO3zdTMbTNVzqec7qp3l/o16KcutbrI293b1U0v1ZJSkrTn3B7tPLPTFqJ2Re9STGKMw/oVfSvqXMK5bLfL/aUAACg9CFcoFgzD0PDvhmvnmZ2q6FtR3w36rlhc7O/r4ave9Xurd/3eSk5N1i9HftHCPQu1ZP8SnU84r9k7Z2v2ztkq41lGd9S9Q33r99XtdW6Xv6e/q5teop1POJ8WoM7s0s7otH/3nt+rFGtKhroebh5qWLGhmoU0U9PgpmoW0kxNgpsoyDtIYdPDdDL2pMPrrkwyqWpAVbWv3r4wdgkAABQBhCsUC6+ue1Xf7vlWHm4eWjRwkWoE1XB1k3LN0+yp7rW7q3vt7pphnaH1x9fbZh48GXdSc/+cq7l/zpW3u7ciwiPUr0E/9azXU0HeQa5uerGVak3VoUuHMgSpk3EnHdYv51POFqDSw1SDig0ynf58evfp6j+/v0wy2QUsk9ImMJnWfRr3oAIAoBQhXKHIW7x3scavHi9J+vCOD9WuejsXtyj/3N3c1SmskzqFddK07tO05eQWLdy7UAv3LtThS4f13f7v9N3+7+Tu5q7ONTurX4N+6lW/lyr5VXJ104us+OR4/XH2D7vT+nZH71aCJcFh/drlatuNRjUNbqqqAVVzNbNj3wZ9tWDAAof3uZrWfZrLJlsBAACuQbhCkfZH9B+6b/F9kqQnWz2ph256yMUtcj43k5taV22t1lVb640ub2h39G4t3LtQi/Yu0l/n/tKKQyu04tAKPbr0UbWv3l79GvRTnwZ9VDWgqqub7hKGYehk3EltvbxVuzfs1h/n/tCu6F06cOGAw9PzfNx91Di4sZoFN1PTkLQg1bhSY5XxKuOU9vRt0Fe96vXSuuPrdDrutELLhKp99faMWAEAUAoRrlBknU84r15zeyneEq/ONTtrasRUVzepwJlMJjUNaaqmIU310q0vaf/5/Vq0d5EW7l2obae3ae2xtVp7bK2eWv6UWldpbbtpcXi5cFc3vUBYUi3ad36f3Wx9O8/s1IWrF9IqHLGvH+ofmhaggv//tL6QpqpTrk6BBx2zm1mdwjoV6GsAAICij3CFIinFSNHgRYN1JOaIwsuGa17/eXJ3K33dtV6FehrXfpzGtR+nYzHH0q7R2rdIG45v0KaTm7Tp5Cb95+f/qElwE9tNixtVbFQsb1p86eqltBn6rrk26q9zfyk5NTlDXbPJrCpeVdQ2vK1uDL3RFqQ4bRIAALhS6fu2imLh05Ofau35tSrjWUbfDfpO5X3Lu7pJLlcjqIaebvO0nm7ztE7HndaSfUu0aN8irT6yWrujd2t39G5NXDNRdcvXtQWt5qHNi1zQshpWHY05mmGSiWOXjzmsH+AVkOHaqLpl6+qXlb+oR48e8vDgXmEAAKBoIFyhyPlo+0f66fxPMsmkr/p+pUaVGrm6SUVOaJlQPdbyMT3W8jFdSLigH/7+QQv3LtTKQyv194W/Fbk+UpHrI1U9sLr61u+rfg37qU3VNoV+HdBVy1X9de6vDEEqLjnOYf2woLAMQSosKCxDQLRYLIXRfAAAgFwhXKFIWXt0rUavHC1JernTy+pZr6drG1QMlPctr2HNhmlYs2GKTYrVsgPLtHDvQi07sEzHLx/XtE3TNG3TNIX4h6h3vd7q17CfOtboKA9zxhGfVGtqnidmiL4SbXdt1K7oXdp3fp+shjVDXS+zlxpVamQ3yUT6vaMAAACKK8IViowjl46o3/x+SrGmqH1Qez3X5jlXN6nYCfAK0KAbBmnQDYN01XJVKw6t0KK9i/T9/u915soZzdw2UzO3zVQ5n3K6q95d6lu/r7qGd5W3u7cW7V3kcErx6d2n200pnmpN1d8X/s4QpM5cOeOwTRV9K9qPRoU0Vb3y9RyGOwAAgOKMcIUi4UryFfWa20sXrl7QTSE3aWSlkUXuWqHixsfDR73r91bv+r2VnJqs1UdWa+HehVqyb4nOJZzT7J2zNXvnbPl7+qtpcFNtOLEhwzZOxp5Uv/n99NCNaVPg74repT/O/qHElMQMdU0yqW75uhmCVKh/KO8lAAAoFQhXcDmrYdX9i+/XH2f/ULBfsBb0X6Dd63e7ulkliqfZUxG1IxRRO0Iz7pih9cfX2+6ldTLupMNgJcl236hPdnxiV+7n4Zc2Zfw110bdUOkG+Xn6Ffi+AAAAFFWEK7jc5DWTtXjfYnmaPbV44GJVDaiq3SJcFRSzm1kdwzqqY1hHTes+TTO3ztQTy57Idr17G9+rXvV7qWlwU4WXC5ebya0QWgsAAFB8EK7gUt/+9a1e+vUlSdJHd36kNtXaMBNcIXIzuamsd9kc1e1Rp4f6N+xfwC0CAAAovvjTM1xmx+kdGrpkqCRpzM1jNLTZUBe3qHQKLRPq1HoAAAClFeEKLhF9JVq95vbS1ZSrigiP0Btd33B1k0qt9tXbq2pAVZnkeNIJk0yqFlBN7au3L+SWAQAAFC+EKxS65NRk9ZvfTydiT6hu+bqa23+u3N04Q9VVzG5mTe8+XZIyBKz0x9O6Tyv0GxADAAAUN4QrFCrDMPT40se14cQGBXoF6vtB33Pj2CKgb4O+WjBggaoEVLErrxpQVQsGLLC7zxUAAAAcY7gAher9ze/r0x2fys3kpm/6faN6Feq5ukn4f30b9FWver207vg6nY47rdAyoWpfvT0jVgAAADlEuEKh+fnwz3p6xdOSpDe7vKnb69zu4hbhemY3szqFdXJ1MwAAAIolTgtEoTh48aAGfDtAqUaq7m96v8a0GePqJgEAAABORbhCgYtNitVd39ylS4mX1LpKa/3vzv/JZHI8Mx0AAABQXBGuUKBSram6Z9E92nt+ryqXqazFAxfL293b1c0CAAAAnI5whQI1fvV4/fj3j/J299aSgUu4ES0AAABKLMIVCsw3f3yjyPWRkqRP7/pULau0dHGLAAAAgIJDuEKB2Hpqqx74/gFJ0ti2YzWk8RAXtwgAAAAoWIQrON3puNPqPbe3ElMSdWfdO/XKba+4ukkAAABAgSNcwakSUxLVZ14fnYw7qQYVGuirvl9xE1oAAACUCoQrOI1hGHr0x0e16eQmlfUuq+8Hf68ArwBXNwsAAAAoFIQrOM07v7+jObvmyGwy69u7v1XtcrVd3SQAAACg0BCu4BTLDy7Xc1HPSZLeiXhHnWt1dnGLAAAAgMJFuEK+7T+/X4MWDJLVsOrBGx/UyFYjXd0kAAAAoNARrpAvMYkxumvuXbqcdFltq7XVBz0+kMlkcnWzAAAAgEJHuEKepVpTNWjBIP194W9VC6imhQMWysvdy9XNAgAAAFyCcIU8+8/P/9GKQyvk4+6j7wZ9p2D/YFc3CQAAAHAZwhXyZM7OOZqycUraz73n6MbQG13cIgAAAMC1CFfItd//+V0P//iwJGl8h/G6u9HdLm4RAAAA4HqEK+TKP7H/qM+8PkpOTVbv+r01qdMkVzcJAAAAKBIIV8ixq5ar6j23t85cOaPGlRrriz5fyM1EFwIAAAAkwhVyyDAMPfj9g9p2epvK+5TXd4O+k7+nv6ubBQAAABQZRSJcffDBBwoLC5O3t7dat26tzZs3Z1q3U6dOMplMGZY77rjDVscwDE2YMEGhoaHy8fFRly5ddODAgcLYlRLrjQ1v6Js/v5G7m7sWDFigmmVrurpJAAAAQJHi8nA1b948jRkzRhMnTtT27dvVtGlTRURE6OzZsw7rL1q0SKdPn7Ytf/75p8xms+6++99JFd588029++67mjlzpjZt2iQ/Pz9FREQoMTGxsHarRPlh/w96YdULkqT3bn9PncI6ubZBAAAAQBHk8nA1depUjRgxQsOHD1fDhg01c+ZM+fr6atasWQ7rlytXTiEhIbYlKipKvr6+tnBlGIamTZumF198Ub169VKTJk30+eef69SpU1qyZEkh7lnJsOfcHt2z6B4ZMvRYi8f0aItHXd0kAAAAoEhyd+WLJycna9u2bRo3bpytzM3NTV26dNHGjRtztI1PP/1UgwYNkp+fnyTpyJEjOnPmjLp06WKrExgYqNatW2vjxo0aNGhQhm0kJSUpKSnJ9jg2NlaSZLFYZLFY8rRvJcHFqxd11zd3KS45Th2rd9Tbnd8ulOOR/hql+dgja/QRZIc+gpygnyA79BFIuXv/XRquzp8/r9TUVAUHB9uVBwcHa9++fdmuv3nzZv3555/69NNPbWVnzpyxbeP6baY/d73IyEhNnjw5Q/nKlSvl6+ubbTtKolQjVZMPTdahK4dUybOSHgx4UFErogq1DVFRhft6KH7oI8gOfQQ5QT9BdugjpVtCQkKO67o0XOXXp59+qsaNG6tVq1b52s64ceM0ZswY2+PY2FhVq1ZN3bp1U0BAQH6bWSyNWTlGu6/slp+Hn366/yc1rtS40F7bYrEoKipKXbt2lYeHR6G9LooP+giyQx9BTtBPkB36CKR/z2rLCZeGqwoVKshsNis6OtquPDo6WiEhIVmuGx8fr7lz5+qll16yK09fLzo6WqGhoXbbbNasmcNteXl5ycvLK0O5h4dHqfwgfbL9E72/9X1J0pd9v9RNVW5ySTtK6/FHztFHkB36CHKCfoLs0EdKt9y89y6d0MLT01PNmzfXqlWrbGVWq1WrVq1SmzZtslz322+/VVJSku6991678po1ayokJMRum7Gxsdq0aVO224S0/vh6Pb70cUnSy7e+rN71e7u2QQAAAEAx4fLTAseMGaOhQ4eqRYsWatWqlaZNm6b4+HgNHz5cknT//ferSpUqioyMtFvv008/Ve/evVW+fHm7cpPJpNGjR+uVV15RnTp1VLNmTY0fP16VK1dW7969C2u3iqXjl4+r77y+slgturvh3fpv+/+6ukkAAABAseHycDVw4ECdO3dOEyZM0JkzZ9SsWTMtX77cNiHF8ePH5eZmP8C2f/9+rV+/XitXrnS4zeeff17x8fF6+OGHFRMTo3bt2mn58uXy9vYu8P0pruKT49Vrbi+dSzinG0Nu1Ge9PpPJZHJ1swAAAIBiw+XhSpJGjhypkSNHOnxuzZo1Gcrq1asnwzAy3Z7JZNJLL72U4XosOGYYhoZ9N0w7z+xUJb9KWjJoifw8/VzdLAAA4ESpqalMKZ5LFotF7u7uSkxMVGpqqqubgwLi4eEhs9nslG0ViXAF13rl11e0YM8Cebh5aNGARaoeWN3VTQIAAE5iGIbOnDmjmJgYVzel2DEMQyEhITpx4gRn9JRwQUFBCgkJyff7TLgq5RbvXawJayZIkmbeOVNtq7d1cYsAAIAzpQerSpUqydfXl5CQC1arVVeuXJG/v3+Gy1RQMhiGoYSEBJ09e1aS7GYbzwvCVSm2O3q37lt8nyTpqVZP6YEbH3BxiwAAgDOlpqbagtX1k4Ahe1arVcnJyfL29iZclWA+Pj6SpLNnz6pSpUr5OkWQXlJKnYs/p7u+uUvxlnh1qdVFUyKmuLpJAADAydKvsfL19XVxS4CiLf0zkt/rEglXpVByarL6f9tfxy4fU3jZcM3rP0/ubgxiAgBQUnEqIJA1Z31GCFel0KifRunXY7+qjGcZfT/4e5XzKefqJgEAAADFHuGqlJmxZYZmbpspk0z6ut/XalixoaubBAAAioPUVGnNGumbb9L+LYZTk4eFhWnatGk5rr9mzRqVLVuWmRaRY4SrUmT1kdV6avlTkqTIzpG6s+6dLm4RAAAoFhYtksLCpFtvlYYMSfs3LCytvACYTKYsl0mTJuVpu1u2bNHDDz+c4/q33HKL9u3bp8DAwDy9HkofLrQpJQ5fOqy7v71bKdYUDWk8RM+3fd7VTQIAAMXBokVS//6SYdiXnzyZVr5ggdS3r1Nf8vTp07af582bpwkTJmj//v22Mn9/f9vPhmEoNTVV7u7Zf62tWLFirtrh6emp4ODgEnfNmsVikYeHh6ubUSIxclUKxCXFqdfcXrpw9YJaVG6hT3p+UuJ+SQAAgBwyDCk+PmdLbKz01FMZg1X6diRp1Ki0ejnZnqPtOBASEmJbAgMDZTKZbI/37dunMmXK6KefflLz5s3l5eWl9evX69ChQ+rVq5eCg4Pl7++vli1b6ueff7bb7vWnBZpMJn3yySfq06ePfH19VadOHX3//fe2568/LXD27NkKCgrSihUr1KBBA/n7+6t79+52YTAlJUVPPfWUgoKCVL58ef3nP//R0KFD1bt370z399ixY+rZs6fKli0rPz8/NWrUSMuWLbM9/9dff+nOO+9UQECAypQpo/bt2+vQoUOS0qaLf+mll1S1alV5eXmpWbNmWr58uW3do0ePymQyad68eerYsaO8vb311VdfSZI++eQTNWjQQN7e3qpfv74+/PDDHL0/yBzhqoSzGlbdt/g+/Xn2T4X4h2jJwCXy8fBxdbMAAICrJCRI/v45WwID00aoMmMY0j//pNXLyfYSEpy2G2PHjtXrr7+uvXv3qkmTJrpy5Yp69OihVatWaceOHerevbt69uyp48ePZ7mdyZMna8CAAdq9e7d69Oihe+65RxcvXsy0fkJCgt5++2198cUX+vXXX3X8+HE9++yztuffeOMNffXVV/rss8+0YcMGxcbGasmSJVm24YknnlBSUpJ+/fVX/fHHH3rjjTdso3MnT55Uhw4d5OXlpV9++UXbtm3TAw88oJSUFEnS9OnTNWXKFL399tvavXu3IiIidNddd+nAgQMZjteoUaO0d+9eRURE6KuvvtKECRP06quvau/evXrttdc0fvx4zZkzJ8u2IhsGMrh8+bIhybh8+bKrm5Jv438Zb2iSDK+XvYzfT/zu6ubkSHJysrFkyRIjOTnZ1U1BEUUfQXboI8iJ0tBPrl69auzZs8e4evXqv4VXrhhGWiwq/OXKlVzvw2effWYEBgbaHq9evdqQZCxZsiTbdRs1amS89957tsc1atQw3nnnHdtjScaLL754zaG5YkgyfvrpJ8MwDGPVqlWGJOPChQu2tkgyDh48aFvngw8+MIKDg22Pg4ODjbfeesv2OCUlxahevbrRq1evTNvZuHFjY9KkSQ6fGzdunFGzZs1M+2nlypWNV1991a6sZcuWxuOPP24YhmEcOXLEkGRMmzbNrk54eLjx9ddf25W9/PLLRps2bTJtZ0nm8LPy/3KTDbjmqgSb/9d8vfzry5Kkj3p+pNZVW7u4RQAAwOV8faUrV3JW99dfpR49sq+3bJnUoUPOXttJWrRoYff4ypUrmjRpkpYuXarTp08rJSVFV69ezXbkqkmTJraf/fz8FBAQoLNnz2Za39fXV+Hh4bbHoaGhtvqXL19WdHS0WrVqZXvebDarefPmslqtmW7zqaee0mOPPaaVK1eqS5cu6tevn61dO3fuVPv27R1eIxUbG6tTp06pbdu2duVt27bVrl277MquPV7x8fE6dOiQHnzwQY0YMcJWnpKSwuQd+US4KqF2nN6hYUuGSZKebfOs7m96v2sbBAAAigaTSfLzy1ndbt2kqlXTTg10dL2UyZT2fLduktns3HZmw++6fXj22WcVFRWlt99+W7Vr15aPj4/69++v5OTkLLdzfWgxmUxZBiFH9Y0cXkuWmYceekgRERFaunSpVq5cqcjISE2ZMkVPPvmkfHyccznHtcfryv+H648//litW9v/8d1cyO9jScM1VyVQ9JVo9ZrbS1dTrqp77e56vcvrrm4SAAAojsxmafr0tJ+vnwwr/fG0aYUerBzZsGGDhg0bpj59+qhx48YKCQnR0aNHC7UNgYGBCg4O1pYtW2xlqamp2r59e7brVqtWTY8++qgWLVqkZ555Rh9//LGktJG1devWyWKxZFgnICBAlStX1oYNG+zKN2zYoIYNM7+XaXBwsCpXrqzDhw+rdu3adkvNmjVzurtwgJGrEiYpJUl95/fVidgTqle+nr7p943Mbq7/hQcAAIqpvn3TplsfNSpt8op0VaumBSsnT8OeV3Xq1NGiRYvUs2dPmUwmjR8/PssRqILy5JNPKjIyUrVr11b9+vX13nvv6dKlS1nO1Dx69Gjdfvvtqlu3ri5duqTVq1erQYMGkqSRI0fqvffe06BBgzRu3DgFBgbq999/V6tWrVSvXj0999xzmjhxosLDw9WsWTN99tln2rlzp21GwMxMnjxZTz31lAIDA9W9e3clJSVp69atunTpksaMGePUY1KaEK5KEMMw9PjSx/Xbid8U6BWo7wd/ryDvIFc3CwAAFHd9+0q9eknr1kmnT0uhoVL79kVixCrd1KlT9cADD+iWW25RhQoV9J///EexsbGF3o7//Oc/OnPmjO6//36ZzWY9/PDDioiIyPJ0u9TUVD3xxBP6559/FBAQoO7du+udd96RJJUvX16//PKLnnvuOXXs2FFms1nNmjWzXWf11FNP6fLly3rmmWd09uxZNWzYUN9//73q1KmTZTsfeugh+fr66q233tJzzz0nPz8/NW7cWKNHj3basSiNTEZ+TxItgWJjYxUYGKjLly8rICDA1c3JsXc3vatRy0fJzeSmZUOWKaJ2hKublCcWi0XLli1Tjx49uMEdHKKPIDv0EeREaegniYmJOnLkiGrWrClvb29XN6fYsVqtio2NVUBAgNzc8nY1jdVqVYMGDTRgwAC9/PLLTm4hnCWrz0pusgEjVyVE1KEoPb3iaUnS213fLrbBCgAAoDg7duyYVq5cqY4dOyopKUnvv/++jhw5oiFDhri6aSgETGhRAhy4cEADFwyU1bBqWLNhGn3zaFc3CQAAoFRyc3PT7Nmz1bJlS7Vt21Z//PGHfv75Z9s1VCjZGLkq5i4nXlavub10KfGS2lRto5l3zMzygkkAAAAUnGrVqmWYvQ+lByNXxViqNVX3LLpHe8/vVdWAqlo0cJG83L1c3SwAAACgVCJcFWP//eW/WnpgqbzdvbVk4BKF+Ie4ukkAAABAqUW4Kqa+2v2V3tjwhiTps16fqXnl5i5uEQAAAFC6Ea6KoS0nt+jB7x+UJI1rN06Dbhjk4hYBAAAAIFwVM6fiTqn3vN5KSk1Sz7o99cptr7i6SQAAAABEuCpWElMS1WdeH52KO6WGFRvqy75fys3EWwgAAAAUBXwzL8JSralac3SNvvnjG60+sloPff+QNp/crLLeZfX9oO8V4JX1HaIBAACc5drvJWuOrlGqNdXVTSoxZs+eraCgINvjSZMmqVmzZlmuM2zYMPXu3Tvfr+2s7SAN97kqohbtXaRRy0fpn9h/7Mrd5KZv7/5W4eXCXdQyAABQ2jj6XlI1oKqmd5+uvg36FtjrnjlzRq+++qqWLl2qkydPqlKlSmrWrJlGjx6tzp07F9jrutqzzz6rJ5980qnbPHr0qGrWrKkdO3bYBbfp06fLMAynvlZpRrgqghbtXaT+8/vLUMaObpVVl5Muu6BVAACgNMrse8nJ2JPqP7+/FgxYUCAB6+jRo2rbtq2CgoL01ltvqXHjxrJYLFqxYoWeeOIJ7du3z+F6FotFHh4eTm9PYfL395e/v3+hvFZgYGChvE5hSk5Olqenp0tem9MCi5hUa6pGLR/lMFhJkkkmjV4+mqF4AACQJ4ZhKD45PkdLbGKsnvrpKYffS9LLRv00SrGJsTnaXm5GSB5//HGZTCZt3rxZ/fr1U926ddWoUSONGTNGv//+u62eyWTSjBkzdNddd8nPz0+vvvqqJGnGjBkKDw+Xp6en6tWrpy+++MLuGEyaNEnVq1eXl5eXKleurKeeesr2/Icffqg6derI19dXdevW1d133+2wjVarVVWrVtWMGTPsynfs2CE3NzcdO3ZMkjR16lQ1btxYfn5+qlatmh5//HFduXIl032//rTA1NRUjRkzRkFBQSpfvryef/75DMdy+fLlateuna3OnXfeqUOHDtmer1mzpiTpxhtvlMlkUqdOnSRlPC0wKSlJTz31lCpVqiRvb2+1a9dOW7ZssT2/Zs0amUwmrVq1Si1atJCvr69uueUW7d+/P9P9SU5O1siRIxUaGipvb2/VqFFDkZGRtudjYmL0yCOPKDg4WN7e3rrhhhv0448/2p5fuHChGjVqJC8vL4WFhWnKlCl22w8LC9PLL7+s+++/XwEBAXr44YclSevXr1f79u3l4+OjatWq6amnnlJ8fHym7XQGRq6KmHXH12U4FfBahgydiD2hdcfXqVNYp8JrGAAAKBESLAnyj3TOqIghQ//E/aPAN3I2+nFl3BX5efplW+/ixYtavny5Xn31Vfn5Zax/7fVJUloYef311zVt2jS5u7tr8eLFGjVqlKZNm6YuXbroxx9/1PDhw1W1alXdeuutWrhwod555x3NnTtXjRo10pkzZ7Rr1y5J0tatW/XUU0/piy++0M0336wTJ05ox44dDtvp5uamwYMH6+uvv9Zjjz1mK//qq6/Utm1b1ahRw1bv3XffVc2aNXX48GE9/vjjev755/Xhhx/m6LhNmTJFs2fP1qxZs9SgQQNNmTJFixcv1m233WarEx8frzFjxqhJkya6cuWKJkyYoD59+mjnzp1yc3PT5s2b1apVK/38889q1KhRpiM7zz//vBYuXKg5c+aoRo0aevPNNxUREaGDBw+qXLlytnr//e9/NWXKFFWsWFGPPvqoHnjgAW3YsMHhNt999119//33mj9/vqpXr64TJ07oxIkTktIC6u233664uDh9+eWXCg8P1549e2Q2myVJ27Zt04ABAzRp0iQNHDhQv/32mx5//HGVL19ew4YNs73G22+/rQkTJmjixImSpEOHDql79+565ZVXNGvWLJ07d04jR47UyJEj9dlnn+XouOcF4aqIOR132qn1AAAAipuDBw/KMAzVr18/R/WHDBmi4cOH2x4PHjxYw4YN0+OPPy5JttGut99+W7feequOHz+ukJAQdenSRR4eHqpevbpatWolSTp+/Lj8/Px05513ys/PT2XLllW7du0yfe177rlHU6ZM0fHjx1W9enVZrVbNnTtXL774oq3O6NGjbT+HhYXplVde0aOPPprjcDVt2jSNGzdOffumnX45c+ZMrVixwq5Ov3797B7PmjVLFStW1J49e3TDDTeoYsWKkqTy5csrJCTE4evEx8drxowZmj17tm6//XZJ0scff6yoqCh9+umneu6552x1X331VXXs2FGSNHbsWN1xxx1KTEyUt7d3hu0eP35cderUUbt27WQymWyhU5J+/vlnbd68WXv37lXdunUlSbVq1bI9P3XqVHXu3Fnjx4+XJNWtW1d79uzRW2+9ZReubrvtNj3zzDO2xw899JDuuece27GvU6eO3n33XXXs2FEzZsxw2E5nIFwVMaFlQp1aDwAA4Fq+Hr66Mi7zU9Ku9euxX9Xj6x7Z1ls2ZJk61OiQo9fOidxOsNCiRQu7x3v37rWdGpaubdu2mj59uiTp7rvv1rRp01SrVi11795dPXr0UM+ePeXu7q6uXbuqRo0aqlWrliIiItShQwcNGTJE/v7++uqrr/TII4/YtvnTTz+pffv2atCggb7++muNHTtWa9eu1dmzZ+1OJfz5558VGRmpffv2KTY2VikpKUpMTFRCQoJ8fbM+JpcvX9bp06fVunVrW5m7u7tatGhhd5wOHDigCRMmaNOmTTp//rysVquktGBzww035Og4Hjp0SBaLRW3btrWVeXh4qFWrVtq7d69d3SZNmth+Dg1N+1569uxZVa9ePcN2hw0bpq5du6pevXrq3r277rzzTnXr1k2StHPnTlWtWtUWrK63d+9e9erVy66sbdu2mjZtmlJTU20jXNf3gV27dmn37t366quvbGWGYchqterIkSNq0KBBtscjL7jmqohpX729qgZUlUkmh8+bZFK1gGpqX719IbcMAACUBCaTSX6efjlauoV3y9H3km7h3XK0PZPJ8XauV6dOHZlMpkwnrbieo1MHs1KtWjXt379fH374oXx8fPT444+rQ4cOslgsKlOmjLZv365vvvlGoaGhioyM1I033qiYmBjddddd2rlzp21J/0J/zz336Ouvv5Ykff311+revbvKly8vKW1ijjvvvFNNmjTRwoULtW3bNn3wwQeS0q5FcpaePXvq4sWL+vjjj7Vp0yZt2rTJ6a9xrWsnDUl/X9MD3fVuuukmHTlyRC+//LKuXr2qAQMGqH///pIkHx8fp7Tn+j5w5coVPfLII3bv165du3TgwAGFhxfcrNuEqyLG7GbW9O5pf1W5/hdZ+uNp3afJ7GYu9LYBAIDSxVXfS8qVK6eIiAh98MEHDicgiImJyXL9Bg0aZLj+Z8OGDWrYsKHtsY+Pj3r27Kl3331Xa9as0caNG/XHH39IShsZ6tKli9544w2tX79eR48e1S+//KIyZcqodu3atiU9GAwZMkR//vmntm3bpgULFuiee+6xvc62bdtktVo1ZcoU3Xzzzapbt65OnTqV42MRGBio0NBQW1iSpJSUFG3bts32+MKFC9q/f79efPFFde7cWQ0aNNClS5fstpN+jVVqauaToqVPAHLtsbNYLNqyZYvdscuLgIAADRw4UB9//LHmzZunhQsX6uLFi2rSpIn++ecf/f333w7Xy+y9rFu3rm3UypGbbrpJe/bssXu/0peCnEmQ0wKLoL4N+mrBgAUO7ycxrfu0Ar2fBAAAwLVc9b3kgw8+UNu2bdWqVSu99NJLatKkiVJSUhQVFaUZM2ZkOE3tWs8995wGDBigG2+8UV26dNEPP/ygRYsW6eeff5aUdtPe1NRUtW7dWr6+vvryyy/l4+OjGjVq6Mcff9Thw4fVoUMHBQYGatGiRbJarapXr16mrxcWFqZbbrlFDz74oFJTU3XXXXfZnqtdu7YsFovee+899ezZUxs2bNDMmTNzdSxGjRql119/XXXq1FH9+vU1depUu4BZtmxZlS9fXh999JFCQ0N1/PhxjR071m4blSpVko+Pj5YvX66qVavK29s7wzTsfn5+euyxx/Tcc8+pXLlyql69ut58800lJCTowQcfzFWbrzV16lSFhobqxhtvlJubm7799luFhIQoKChIHTt2VIcOHdSvXz9NnTpVtWvX1r59+2QymdS9e3c988wzatmypV5++WUNHDhQGzdu1Pvvv5/t9Wr/+c9/dPPNN2vkyJF66KGH5Ofnpz179igqKkrvv/9+nvclWwYyuHz5siHJuHz5skvbkZKaYqw+str4evfXxuojq42U1BSXtqewJCcnG0uWLDGSk5Nd3RQUUfQRZIc+gpwoDf3k6tWrxp49e4yrV6/me1uu+F5y6tQp44knnjBq1KhheHp6GlWqVDHuuusuY/Xq1bY6kozFixdnWPfDDz80atWqZXh4eBh169Y1Pv/8c9tzixcvNlq3bm0EBAQYfn5+xs0332z8/PPPhmEYxrp164yOHTsaZcuWNXx8fIxGjRoZ33zzTbZt/fDDDw1Jxv3335/hualTpxqhoaGGj4+PERERYXz++eeGJOPSpUuGYRjGZ599ZgQGBtrqT5w40WjatKntscViMUaNGmUEBAQYQUFBxpgxY4z777/f6NWrl61OVFSU0aBBA8PLy8to0qSJsWbNmgzH5uOPPzaqVatmuLm5GR07djQMwzCGDh1qt52rV68aTz75pFGhQgXDy8vLaNu2rbF582bb86tXr7Zru2EYxo4dOwxJxpEjRxwem48++sho1qyZ4efnZwQEBBidO3c2tm/fbnv+woULxvDhw43y5csb3t7exg033GD8+OOPtucXLFhgNGzY0PDw8DCqV69uvPXWW3bbr1GjhvHOO+9keN3NmzcbXbt2Nfz9/Q0/Pz+jSZMmxquvvuqwjVl9VnKTDUyGwS2ZrxcbG6vAwEBdvnxZAQEBrm5OqWOxWLRs2TL16NGj2N8EEAWDPoLs0EeQE6WhnyQmJurIkSOqWbNmgc2OVpJZrVbFxsYqICBAbm5cTVOSZfVZyU02oJcAAAAAgBMQrgAAAADACQhXAAAAAOAEhCsAAAAAcALCFQAAQAnH/GVA1pz1GSFcAQAAlFDpsyAmJCS4uCVA0Zb+GcnvzKHcRBgAAKCEMpvNCgoK0tmzZyVJvr6+MplMLm5V8WG1WpWcnKzExESmYi+hDMNQQkKCzp49q6CgIJnN5nxtj3AFAABQgoWEhEiSLWAh5wzD0NWrV+Xj40MoLeGCgoJsn5X8IFwBAACUYCaTSaGhoapUqZIsFourm1OsWCwW/frrr+rQoUOJvdE00k4FzO+IVTrCFQAAQClgNpud9gWytDCbzUpJSZG3tzfhCjnCyaMAAAAA4ASEKwAAAABwAsIVAAAAADgB11w5kH4TsdjYWBe3pHSyWCxKSEhQbGws5zfDIfoIskMfQU7QT5Ad+gikfzNBTm40TLhyIC4uTpJUrVo1F7cEAAAAQFEQFxenwMDALOuYjJxEsFLGarXq1KlTKlOmDPc0cIHY2FhVq1ZNJ06cUEBAgKubgyKIPoLs0EeQE/QTZIc+AiltxCouLk6VK1fO9mbSjFw54ObmpqpVq7q6GaVeQEAAv8iQJfoIskMfQU7QT5Ad+giyG7FKx4QWAAAAAOAEhCsAAAAAcALCFYocLy8vTZw4UV5eXq5uCooo+giyQx9BTtBPkB36CHKLCS0AAAAAwAkYuQIAAAAAJyBcAQAAAIATEK4AAAAAwAkIVwAAAADgBIQrFIpff/1VPXv2VOXKlWUymbRkyRK75w3D0IQJExQaGiofHx916dJFBw4csKtz8eJF3XPPPQoICFBQUJAefPBBXblypRD3AgUpMjJSLVu2VJkyZVSpUiX17t1b+/fvt6uTmJioJ554QuXLl5e/v7/69eun6OhouzrHjx/XHXfcIV9fX1WqVEnPPfecUlJSCnNXUEBmzJihJk2a2G7m2aZNG/3000+25+kfuN7rr78uk8mk0aNH28roJ5g0aZJMJpPdUr9+fdvz9BHkB+EKhSI+Pl5NmzbVBx984PD5N998U++++65mzpypTZs2yc/PTxEREUpMTLTVueeee/TXX38pKipKP/74o3799Vc9/PDDhbULKGBr167VE088od9//11RUVGyWCzq1q2b4uPjbXWefvpp/fDDD/r222+1du1anTp1Sn379rU9n5qaqjvuuEPJycn67bffNGfOHM2ePVsTJkxwxS7ByapWrarXX39d27Zt09atW3XbbbepV69e+uuvvyTRP2Bvy5Yt+t///qcmTZrYldNPIEmNGjXS6dOnbcv69ettz9FHkC8GUMgkGYsXL7Y9tlqtRkhIiPHWW2/ZymJiYgwvLy/jm2++MQzDMPbs2WNIMrZs2WKr89NPPxkmk8k4efJkobUdhefs2bOGJGPt2rWGYaT1CQ8PD+Pbb7+11dm7d68hydi4caNhGIaxbNkyw83NzThz5oytzowZM4yAgAAjKSmpcHcAhaJs2bLGJ598Qv+Anbi4OKNOnTpGVFSU0bFjR2PUqFGGYfB7BGkmTpxoNG3a1OFz9BHkFyNXcLkjR47ozJkz6tKli60sMDBQrVu31saNGyVJGzduVFBQkFq0aGGr06VLF7m5uWnTpk2F3mYUvMuXL0uSypUrJ0natm2bLBaLXT+pX7++qlevbtdPGjdurODgYFudiIgIxcbG2kY3UDKkpqZq7ty5io+PV5s2begfsPPEE0/ojjvusOsPEr9H8K8DBw6ocuXKqlWrlu655x4dP35cEn0E+efu6gYAZ86ckSS7X1Lpj9OfO3PmjCpVqmT3vLu7u8qVK2erg5LDarVq9OjRatu2rW644QZJaX3A09NTQUFBdnWv7yeO+lH6cyj+/vjjD7Vp00aJiYny9/fX4sWL1bBhQ+3cuZP+AUnS3LlztX37dm3ZsiXDc/wegSS1bt1as2fPVr169XT69GlNnjxZ7du3159//kkfQb4RrgAUOU888YT+/PNPu3PgAUmqV6+edu7cqcuXL2vBggUaOnSo1q5d6+pmoYg4ceKERo0apaioKHl7e7u6OSiibr/9dtvPTZo0UevWrVWjRg3Nnz9fPj4+LmwZSgJOC4TLhYSESFKGmXiio6Ntz4WEhOjs2bN2z6ekpOjixYu2OigZRo4cqR9//FGrV69W1apVbeUhISFKTk5WTEyMXf3r+4mjfpT+HIo/T09P1a5dW82bN1dkZKSaNm2q6dOn0z8gKe2UrrNnz+qmm26Su7u73N3dtXbtWr377rtyd3dXcHAw/QQZBAUFqW7dujp48CC/S5BvhCu4XM2aNRUSEqJVq1bZymJjY7Vp0ya1adNGktSmTRvFxMRo27Zttjr/1879x1RV/nEAf1+IC1x+B3i5OSAMUjBYcSUFW9owuVF3RPPHCNGk5dJE3dBJSxz0wygUaP7YnC1w5srWD8gYBYSYkiYlCiy9KEPZ2lUmUUn88sLn+4fzrCs/jav01fdrO9t5zvOc53yewzPgs+ecU1VVhYGBAcycOfOOx0y2JyJYvXo1vvrqK1RVVSEoKMiqXq/Xw8HBwWqemEwmtLa2Ws2ThoYGq0S8oqIC7u7uCAsLuzMDoTtqYGAAvb29nB8EAIiNjUVDQwNOnTqlbDNmzEBycrKyz3lCN+vs7ERzczN0Oh1/l9D4TfQXNejecPXqVamrq5O6ujoBIHl5eVJXVycXL14UEZGcnBzx9PSUkpISqa+vl4SEBAkKCpLu7m6lD4PBII899pj89NNPcvToUQkJCZGkpKSJGhLZ2MqVK8XDw0Oqq6vFbDYrW1dXl9Lm1VdflYCAAKmqqpKff/5ZoqOjJTo6Wqm3WCzyyCOPyPz58+XUqVPy7bffiq+vr7z++usTMSSysYyMDDl8+LC0tLRIfX29ZGRkiEqlkvLychHh/KCh/fNrgSKcJySSnp4u1dXV0tLSIjU1NTJv3jzx8fGRtrY2EeEcofFhckV3xKFDhwTAoG3ZsmUicv1z7JmZmaLVasXR0VFiY2PFZDJZ9dHe3i5JSUni6uoq7u7usnz5crl69eoEjIZuh6HmBwApLCxU2nR3d8uqVavEy8tLNBqNJCYmitlsturnwoUL8swzz4izs7P4+PhIenq6XLt27Q6Phm6H1NRUCQwMFLVaLb6+vhIbG6skViKcHzS0m5MrzhNavHix6HQ6UavVMnnyZFm8eLGcP39eqeccofFQiYhMzJoZERERERHR3YPvXBEREREREdkAkysiIiIiIiIbYHJFRERERERkA0yuiIiIiIiIbIDJFRERERERkQ0wuSIiIiIiIrIBJldEREREREQ2wOSKiIiIiIjIBphcERHRhHjwwQdRUFAw5vbV1dVQqVT4448/bltMd4OioiJ4enpOdBhERPckJldERDQilUo14paVlfWv+q2trcWKFSvG3D4mJgZmsxkeHh7/6npjdSOJG2q7dOnSbb02ERH9f7tvogMgIqL/NrPZrOwfOHAAmzdvhslkUo65uroq+yKC/v5+3Hff6H9efH19bykOtVoNPz+/WzpnPEwmE9zd3a2OTZo06Y5dn4iI/v9w5YqIiEbk5+enbB4eHlCpVEr57NmzcHNzQ1lZGfR6PRwdHXH06FE0NzcjISEBWq0Wrq6uiIqKQmVlpVW/Nz8WqFKp8OGHHyIxMREajQYhISH4+uuvlfqbHwu88fjbd999h9DQULi6usJgMFglgxaLBWvWrIGnpye8vb2xceNGLFu2DM8///yo4540aZLV2P38/GBnZ4eenh5Mnz7datWtubkZbm5u+OijjwAA7e3tSEpKwuTJk6HRaBAeHo5PPvnEqv+5c+ciLS0N69atg5eXF7RaLfbs2YO///4by5cvh5ubG4KDg1FWVjboHpSWliIiIgJOTk6YNWsWGhsbRxxLSUkJIiMj4eTkhClTpiA7OxsWiwXA9YQ4KysLAQEBcHR0xAMPPIA1a9aMen+IiGgwJldERDRuGRkZyMnJwZkzZxAREYHOzk7Ex8fj+++/R11dHQwGA4xGI1pbW0fsJzs7G4sWLUJ9fT3i4+ORnJyM33//fdj2XV1d2Lp1K/bt24cffvgBra2tWL9+vVL/3nvvYf/+/SgsLERNTQ3++usvFBcXj2usTk5O2L9/P/bu3YuSkhL09/djyZIlePrpp5GamgoA6OnpgV6vR2lpKRobG7FixQqkpKTgxIkTVn3t3bsXPj4+OHHiBNLS0rBy5UosXLgQMTExOHnyJObPn4+UlBR0dXVZnbdhwwZs27YNtbW18PX1hdFoxLVr14aM98iRI1i6dCnWrl2LX3/9Fbt370ZRURHeeecdAMAXX3yB/Px87N69G+fOnUNxcTHCw8PHdY+IiO5ZQkRENEaFhYXi4eGhlA8dOiQApLi4eNRzp0+fLtu3b1fKgYGBkp+fr5QByKZNm5RyZ2enAJCysjKra3V0dCixAJDz588r5+zcuVO0Wq1S1mq1kpubq5QtFosEBARIQkLCsHHeuI6Li4vVFhYWZtXu/fffFx8fH1m9erXodDq5cuXKiON/9tlnJT09XSnPmTNHnnjiCavYXFxcJCUlRTlmNpsFgBw7dswqtk8//VRp097eLs7OznLgwAHlvvzzZxQbGytbtmyximXfvn2i0+lERGTbtm3y8MMPS19f34jxExHR6PjOFRERjduMGTOsyp2dncjKykJpaSnMZjMsFgu6u7tHXbmKiIhQ9l1cXODu7o62trZh22s0Gjz00ENKWafTKe3//PNPXL58GY8//rhSb29vD71ej4GBgVHHdOTIEbi5uSllBwcHq/r09HQUFxdjx44dKCsrg7e3t1LX39+PLVu24LPPPsNvv/2Gvr4+9Pb2QqPRDDtee3t7eHt7W60aabVaABh0D6Kjo5X9+++/H1OnTsWZM2eGHMfp06dRU1OjrFTdiK+npwddXV1YuHAhCgoKMGXKFBgMBsTHx8NoNI7pvTkiIrLG35xERDRuLi4uVuX169ejoqICW7duRXBwMJydnbFgwQL09fWN2M/NCYxKpRoxERqqvYjcYvRDCwoKGvGT5m1tbWhqaoK9vT3OnTsHg8Gg1OXm5uKDDz5AQUEBwsPD4eLignXr1g0a/1Dx//OYSqUCgDElg8Pp7OxEdnY2XnjhhUF1Tk5O8Pf3h8lkQmVlJSoqKrBq1Srk5ubi8OHDg+IjIqKRMbkiIiKbq6mpwUsvvYTExEQA1//Bv3Dhwh2NwcPDA1qtFrW1tXjyyScBXF+xOXnyJB599NFx95+amorw8HC8/PLLeOWVVzBv3jyEhoYCuD7+hIQELFmyBMD15KipqQlhYWHjvi4AHD9+HAEBAQCAjo4ONDU1Kde+WWRkJEwmE4KDg4ftz9nZGUajEUajEa+99hqmTZuGhoYGREZG2iReIqJ7BZMrIiKyuZCQEHz55ZcwGo1QqVTIzMwc1+rLv5WWloZ3330XwcHBmDZtGrZv346Ojg5lRWgkbW1t6OnpsTrm7e0NBwcH7Ny5E8eOHUN9fT38/f1RWlqK5ORkHD9+HGq1GiEhIfj888/x448/wsvLC3l5ebh8+bLNkqs333wT3t7e0Gq1eOONN+Dj4zPsFxA3b96M5557DgEBAViwYAHs7Oxw+vRpNDY24u2330ZRURH6+/sxc+ZMaDQafPzxx3B2dkZgYKBNYiUiupfwa4FERGRzeXl58PLyQkxMDIxGI+Li4iZkFWTjxo1ISkrC0qVLER0dDVdXV8TFxcHJyWnUc6dOnQqdTme1/fLLLzh79iw2bNiAXbt2wd/fHwCwa9cuXLlyBZmZmQCATZs2ITIyEnFxcZg7dy78/PzG9Pn3scrJycHatWuh1+tx6dIlHDx4EGq1esi2cXFx+Oabb1BeXo6oqCjMmjUL+fn5SvLk6emJPXv2YPbs2YiIiEBlZSUOHjxo9Q4ZERGNjUps9XA6ERHRf9zAwABCQ0OxaNEivPXWWxMdzi2rrq7GU089hY6OjhHfByMioonBxwKJiOiudfHiRZSXl2POnDno7e3Fjh070NLSghdffHGiQyMiorsQHwskIqK7lp2dHYqKihAVFYXZs2ejoaEBlZWVw378gYiIaDz4WCAREREREZENcOWKiIiIiIjIBphcERERERER2QCTKyIiIiIiIhtgckVERERERGQDTK6IiIiIiIhsgMkVERERERGRDTC5IiIiIiIisgEmV0RERERERDbwPyFGOwWw/T0vAAAAAElFTkSuQmCC",
            "text/plain": [
              "Result(<Figure size 1000x600 with 1 Axes>)"
            ]
          },
          "execution_count": 7,
          "metadata": {},
          "output_type": "execute_result"
        }
      ],
      "source": [
        "from e2b_code_interpreter import Sandbox\n",
        "\n",
        "with Sandbox(api_key=E2B_API_KEY) as code_interpreter:\n",
        "  # Upload the dataset to the code interpreter sandbox\n",
        "  upload_dataset(code_interpreter)\n",
        "\n",
        "  code_results = chat(\n",
        "    code_interpreter,\n",
        "    \"Clean the data, train a decision tree to predict the survival of passengers, and visualize the learning curve. Then run the model the test dataset and print the results.\"\n",
        "  )\n",
        "  if code_results:\n",
        "    first_result = code_results[0]\n",
        "  else:\n",
        "    raise Exception(\"No code interpreter results\")\n",
        "\n",
        "first_result"
      ]
    }
  ],
  "metadata": {
    "colab": {
      "provenance": []
    },
    "kernelspec": {
      "display_name": "Python 3",
      "name": "python3"
    },
    "language_info": {
      "codemirror_mode": {
        "name": "ipython",
        "version": 3
      },
      "file_extension": ".py",
      "mimetype": "text/x-python",
      "name": "python",
      "nbconvert_exporter": "python",
      "pygments_lexer": "ipython3",
      "version": "3.13.0"
    }
  },
  "nbformat": 4,
  "nbformat_minor": 0
}
